Rövid útmutató: Szándékok felismerése a Speech szolgáltatással és a LUIS-val

Fontos

A LUIS 2025. október 1-jén megszűnik. 2023. április 1-től nem hozhat létre új LUIS-erőforrásokat. Javasoljuk, hogy a LUIS-alkalmazásokat a beszélgetési nyelv megértésére migrálja, hogy kihasználhassa a terméktámogatás és a többnyelvű képességek előnyeit.

A Speech SDK 1.25-ös vagy újabb verziójával a C# és a C++ nyelvhez elérhető a Beszélgetési nyelv megértése (CLU). A szándékok a Speech SDK-val és a CLU-val való felismeréséhez tekintse meg a rövid útmutatót.

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

Ebben a rövid útmutatóban a Speech SDK és a Language Understanding (LUIS) szolgáltatás használatával fogja felismerni a mikrofonból rögzített hangadatok szándékait. Pontosabban a Speech SDK-val fogja rögzíteni a beszédet, és egy előre összeállított tartományt a LUIS-ból az otthoni automatizálás szándékainak azonosításához, például a fény be- és kikapcsolásához.

Előfeltételek

• Azure-előfizetés – Ingyenes létrehozás
• Nyelvi erőforrás létrehozása az Azure Portalon. Az ingyenes tarifacsomag (F0) használatával kipróbálhatja a szolgáltatást, és később frissíthet egy fizetős szintre az éles környezetben. Ezúttal nem lesz szüksége Speech-erőforrásra.
• Szerezze be a language erőforráskulcsot és a régiót. A nyelvi erőforrás üzembe helyezése után válassza az Ugrás az erőforrásra lehetőséget a kulcsok megtekintéséhez és kezeléséhez.

LUIS-alkalmazás létrehozása szándékfelismeréshez

A szándékfelismerés rövid útmutatójának elvégzéséhez létre kell hoznia egy LUIS-fiókot és egy projektet a LUIS előzetes verziójának portálján. Ez a rövid útmutató luis-előfizetést igényel egy olyan régióban, ahol a szándékfelismerés elérhető. A Speech service-előfizetés nem szükséges.

Első lépésként létre kell hoznia egy LUIS-fiókot és -alkalmazást a LUIS előzetes verziójának portálján. A létrehozott LUIS-alkalmazás egy előre összeállított tartományt fog használni az otthoni automatizáláshoz, amely szándékokat, entitásokat és példaszövegeket biztosít. Ha végzett, egy LUIS-végpont fog futni a felhőben, amelyet a Speech SDK használatával hívhat meg.

Kövesse az alábbi utasításokat a LUIS-alkalmazás létrehozásához:

• Rövid útmutató: Előre összeállított tartományi alkalmazás létrehozása

Ha végzett, négy dologra lesz szüksége:

• Ismételt közzététel a Speech Priming kapcsolóval
• A LUIS elsődleges kulcsa
• Az Ön LUIS-helye
• A LUIS-alkalmazás azonosítója

Az alábbi helyen találja ezeket az információkat a LUIS előzetes verziójának portálján:

1. A LUIS előnézeti portálján válassza ki az alkalmazást, majd válassza a Közzététel gombot.

2. Válassza ki az éles pontot, ha a beállítások módosítása lehetőséget használja en-US , és állítsa a Speech priming beállítást a Be állásra. Ezután válassza a Közzététel gombot.

   Fontos

   A beszédfelismerés erősen ajánlott, mivel javítja a beszédfelismerés pontosságát.

   

3. A LUIS előzetes verziós portálján válassza a Kezelés, majd az Azure-erőforrások lehetőséget. Ezen a lapon megtalálja a LUIS-előrejelzési erőforrás LUIS-kulcsát és helyét (más néven régiót).

   

4. Miután megkapta a kulcsot és a helyet, szüksége lesz az alkalmazásazonosítóra. Válassza a Beállítások lehetőséget. az alkalmazásazonosító ezen a lapon érhető el.

   

Projekt megnyitása a Visual Studióban

Ezután nyissa meg a projektet a Visual Studióban.

1. Indítsa el a Visual Studio 2019-et.
2. Töltse be a projektet, és nyissa meg Program.cs.

Kezdje néhány sablonkóddal

Adjunk hozzá néhány olyan kódot, amely csontvázként működik a projektünkhöz. Vegye figyelembe, hogy létrehozott egy aszinkron metódust.RecognizeIntentAsync()

using System;
using System.Threading.Tasks;
using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Intent;

namespace helloworld
{
    class Program
    {
        public static async Task RecognizeIntentAsync()
        {

        }

        static async Task Main()
        {
            await RecognizeIntentAsync();
            Console.WriteLine("Please press <Return> to continue.");
            Console.ReadLine();
        }
    }
}

Beszédkonfiguráció létrehozása

Mielőtt inicializálhat egy IntentRecognizer objektumot, létre kell hoznia egy konfigurációt, amely a LUIS előrejelzési erőforrás kulcsát és helyét használja.

Fontos

A kezdőkulcs és a szerzői kulcsok nem működnek. A korábban létrehozott előrejelzési kulcsot és helyet kell használnia. További információ: LUIS-alkalmazás létrehozása szándékfelismeréshez.

Szúrja be ezt a kódot a RecognizeIntentAsync() metódusba. Győződjön meg arról, hogy frissíti ezeket az értékeket:

• Cserélje le "YourLanguageUnderstandingSubscriptionKey" a LUIS előrejelzési kulcsára.
• Cserélje le "YourLanguageUnderstandingServiceRegion" a LUIS-helyet. Régióazonosító használata a régióból.

Tipp.

Ha segítségre van szüksége ezeknek az értékeknek a megkereséséhez, olvassa el a SZÁNDÉKFELISMERÉSi LUIS-alkalmazás létrehozása című témakört.

Fontos

Ne felejtse el eltávolítani a kulcsot a kódból, amikor elkészült, és soha ne tegye közzé nyilvánosan. Éles környezetben biztonságos módon tárolhatja és érheti el a hitelesítő adatait, például az Azure Key Vaultot. További információkért tekintse meg az Azure AI-szolgáltatások biztonsági cikkét.

var config = SpeechConfig.FromSubscription(
    "YourLanguageUnderstandingSubscriptionKey",
    "YourLanguageUnderstandingServiceRegion");

Ez a minta a metódust használja a FromSubscription() SpeechConfig. Az elérhető módszerek teljes listáját a SpeechConfig osztályban találja.

A Speech SDK alapértelmezés szerint felismeri az en-us nyelvet. A forrásnyelv kiválasztásával kapcsolatos információkért tekintse meg a Beszéd felismerése című témakört.

IntentRecognizer inicializálása

Most hozzunk létre egy IntentRecognizer. Ez az objektum egy használati utasításon belül jön létre, hogy biztosítsa a nem felügyelt erőforrások megfelelő kiadását. Szúrja be ezt a kódot a RecognizeIntentAsync() metódusba, közvetlenül a Speech-konfiguráció alatt.

// Creates an intent recognizer using microphone as audio input.
using (var recognizer = new IntentRecognizer(config))
{

}

LanguageUnderstandingModel és szándékok hozzáadása

Társítania kell egy LanguageUnderstandingModel szándék-felismerőt, és hozzá kell adnia a felismerni kívánt szándékokat. Az előre összeállított tartomány szándékait fogjuk használni az otthoni automatizáláshoz. Szúrja be ezt a kódot az előző szakaszból származó felhasználói utasításba. Győződjön meg arról, hogy lecseréli "YourLanguageUnderstandingAppId" a LUIS-alkalmazásazonosítót.

Tipp.

Ha segítségre van szüksége ennek az értéknek a megkereséséhez, olvassa el a LUIS-alkalmazás létrehozása szándékfelismeréshez című témakört.

// Creates a Language Understanding model using the app id, and adds specific intents from your model
var model = LanguageUnderstandingModel.FromAppId("YourLanguageUnderstandingAppId");
recognizer.AddIntent(model, "YourLanguageUnderstandingIntentName1", "id1");
recognizer.AddIntent(model, "YourLanguageUnderstandingIntentName2", "id2");
recognizer.AddIntent(model, "YourLanguageUnderstandingIntentName3", "any-IntentId-here");

Ez a példa a függvényt AddIntent() használja a szándékok egyéni hozzáadásához. Ha egy modell összes szándékát hozzá szeretné adni, használja AddAllIntents(model) és adja át a modellt.

Szándék felismerése

IntentRecognizer Az objektumból fogja meghívni a metódustRecognizeOnceAsync(). Ez a módszer tudatja a Speech szolgáltatással, hogy egyetlen kifejezést küld a felismeréshez, és hogy a kifejezés azonosítása után a rendszer leállítja a beszéd felismerését.

A felhasználói utasításban adja hozzá ezt a kódot a modell alá.

// Starts recognizing.
Console.WriteLine("Say something...");

// Starts intent recognition, and returns after a single utterance is recognized. The end of a
// single utterance is determined by listening for silence at the end or until a maximum of about 30
// seconds of audio is processed.  The task returns the recognition text as result. 
// Note: Since RecognizeOnceAsync() returns only a single utterance, it is suitable only for single
// shot recognition like command or query. 
// For long-running multi-utterance recognition, use StartContinuousRecognitionAsync() instead.
var result = await recognizer.RecognizeOnceAsync();

Megjelenítési eredmények (vagy hibák)

Amikor a Speech szolgáltatás visszaadja a felismerési eredményt, szeretne valamit tenni vele. Egyszerűnek fogjuk tartani, és kinyomtatjuk az eredményeket a konzolon.

Az alábbi RecognizeOnceAsync()utasításban adja hozzá a következő kódot:

// Checks result.
switch (result.Reason)
{
    case ResultReason.RecognizedIntent:
        Console.WriteLine($"RECOGNIZED: Text={result.Text}");
        Console.WriteLine($"    Intent Id: {result.IntentId}.");
        var json = result.Properties.GetProperty(PropertyId.LanguageUnderstandingServiceResponse_JsonResult);
        Console.WriteLine($"    Language Understanding JSON: {json}.");
        break;
    case ResultReason.RecognizedSpeech:
        Console.WriteLine($"RECOGNIZED: Text={result.Text}");
        Console.WriteLine($"    Intent not recognized.");
        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 update the subscription info?");
        }
        break;
}

A kód ellenőrzése

Ezen a ponton a kódnak a következőképpen kell kinéznie:

Feljegyzés

Megjegyzéseket fűztünk ehhez a verzióhoz.

//
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.md file in the project root for full license information.
//

// <skeleton_1>
using System;
using System.Threading.Tasks;
using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Intent;

namespace helloworld
{
    class Program
    {
        public static async Task RecognizeIntentAsync()
        {
            // </skeleton_1>
            // Creates an instance of a speech config with specified subscription key
            // and service region. Note that in contrast to other services supported by
            // the Cognitive Services Speech SDK, the Language Understanding service
            // requires a specific subscription key from https://www.luis.ai/.
            // The Language Understanding service calls the required key 'endpoint key'.
            // Once you've obtained it, replace with below with your own Language Understanding subscription key
            // and service region (e.g., "westus").
            // The default language is "en-us".
            // <create_speech_configuration>
            var config = SpeechConfig.FromSubscription(
                "YourLanguageUnderstandingSubscriptionKey",
                "YourLanguageUnderstandingServiceRegion");
            // </create_speech_configuration>

            // <create_intent_recognizer_1>
            // Creates an intent recognizer using microphone as audio input.
            using (var recognizer = new IntentRecognizer(config))
            {
                // </create_intent_recognizer_1>

                // <add_intents>
                // Creates a Language Understanding model using the app id, and adds specific intents from your model
                var model = LanguageUnderstandingModel.FromAppId("YourLanguageUnderstandingAppId");
                recognizer.AddIntent(model, "YourLanguageUnderstandingIntentName1", "id1");
                recognizer.AddIntent(model, "YourLanguageUnderstandingIntentName2", "id2");
                recognizer.AddIntent(model, "YourLanguageUnderstandingIntentName3", "any-IntentId-here");
                // </add_intents>

                // To add all of the possible intents from a LUIS model to the recognizer, uncomment the line below:
                // recognizer.AddAllIntents(model);

                // <recognize_intent>
                // Starts recognizing.
                Console.WriteLine("Say something...");

                // Starts intent recognition, and returns after a single utterance is recognized. The end of a
                // single utterance is determined by listening for silence at the end or until a maximum of about 30
                // seconds of audio is processed.  The task returns the recognition text as result. 
                // Note: Since RecognizeOnceAsync() returns only a single utterance, it is suitable only for single
                // shot recognition like command or query. 
                // For long-running multi-utterance recognition, use StartContinuousRecognitionAsync() instead.
                var result = await recognizer.RecognizeOnceAsync();
                // </recognize_intent>

                // <print_results>
                // Checks result.
                switch (result.Reason)
                {
                    case ResultReason.RecognizedIntent:
                        Console.WriteLine($"RECOGNIZED: Text={result.Text}");
                        Console.WriteLine($"    Intent Id: {result.IntentId}.");
                        var json = result.Properties.GetProperty(PropertyId.LanguageUnderstandingServiceResponse_JsonResult);
                        Console.WriteLine($"    Language Understanding JSON: {json}.");
                        break;
                    case ResultReason.RecognizedSpeech:
                        Console.WriteLine($"RECOGNIZED: Text={result.Text}");
                        Console.WriteLine($"    Intent not recognized.");
                        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 update the subscription info?");
                        }
                        break;
                }
                // </print_results>
            // <create_intent_recognizer_2>
            }
            // </create_intent_recognizer_2>
        // <skeleton_2>
        }

        static async Task Main()
        {
            await RecognizeIntentAsync();
            Console.WriteLine("Please press <Return> to continue.");
            Console.ReadLine();
        }
    }
}
// </skeleton_2>

Az alkalmazás létrehozása és futtatása

Most már készen áll az alkalmazás összeállítására és a beszédfelismerés tesztelésére a Speech szolgáltatással.

1. A kód fordítása – A Visual Studio menüsávjában válassza a Build Megoldás létrehozása>lehetőséget.
2. Az alkalmazás indítása – A menüsávon válassza a Hibakeresés indítása hibakeresése> lehetőséget, vagy nyomja le az F5 billentyűt.
3. Felismerés indítása – Arra kéri, hogy angol nyelven beszéljen egy kifejezéssel. A rendszer elküldi a beszédet a Speech szolgáltatásnak, átíratja szövegként, és a konzolon jeleníti meg.

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

Ebben a rövid útmutatóban a Speech SDK és a Language Understanding (LUIS) szolgáltatás használatával fogja felismerni a mikrofonból rögzített hangadatok szándékait. Pontosabban a Speech SDK-val fogja rögzíteni a beszédet, és egy előre összeállított tartományt a LUIS-ból az otthoni automatizálás szándékainak azonosításához, például a fény be- és kikapcsolásához.

Előfeltételek

• Azure-előfizetés – Ingyenes létrehozás
• Nyelvi erőforrás létrehozása az Azure Portalon. Az ingyenes tarifacsomag (F0) használatával kipróbálhatja a szolgáltatást, és később frissíthet egy fizetős szintre az éles környezetben. Ezúttal nem lesz szüksége Speech-erőforrásra.
• Szerezze be a language erőforráskulcsot és a régiót. A nyelvi erőforrás üzembe helyezése után válassza az Ugrás az erőforrásra lehetőséget a kulcsok megtekintéséhez és kezeléséhez.

LUIS-alkalmazás létrehozása szándékfelismeréshez

A szándékfelismerés rövid útmutatójának elvégzéséhez létre kell hoznia egy LUIS-fiókot és egy projektet a LUIS előzetes verziójának portálján. Ez a rövid útmutató luis-előfizetést igényel egy olyan régióban, ahol a szándékfelismerés elérhető. A Speech service-előfizetés nem szükséges.

Első lépésként létre kell hoznia egy LUIS-fiókot és -alkalmazást a LUIS előzetes verziójának portálján. A létrehozott LUIS-alkalmazás egy előre összeállított tartományt fog használni az otthoni automatizáláshoz, amely szándékokat, entitásokat és példaszövegeket biztosít. Ha végzett, egy LUIS-végpont fog futni a felhőben, amelyet a Speech SDK használatával hívhat meg.

Kövesse az alábbi utasításokat a LUIS-alkalmazás létrehozásához:

• Rövid útmutató: Előre összeállított tartományi alkalmazás létrehozása

Ha végzett, négy dologra lesz szüksége:

• Ismételt közzététel a Speech Priming kapcsolóval
• A LUIS elsődleges kulcsa
• Az Ön LUIS-helye
• A LUIS-alkalmazás azonosítója

Az alábbi helyen találja ezeket az információkat a LUIS előzetes verziójának portálján:

1. A LUIS előnézeti portálján válassza ki az alkalmazást, majd válassza a Közzététel gombot.

2. Válassza ki az éles pontot, ha a beállítások módosítása lehetőséget használja en-US , és állítsa a Speech priming beállítást a Be állásra. Ezután válassza a Közzététel gombot.

   Fontos

   A beszédfelismerés erősen ajánlott, mivel javítja a beszédfelismerés pontosságát.

   

3. A LUIS előzetes verziós portálján válassza a Kezelés, majd az Azure-erőforrások lehetőséget. Ezen a lapon megtalálja a LUIS-előrejelzési erőforrás LUIS-kulcsát és helyét (más néven régiót).

   

4. Miután megkapta a kulcsot és a helyet, szüksége lesz az alkalmazásazonosítóra. Válassza a Beállítások lehetőséget. az alkalmazásazonosító ezen a lapon érhető el.

   

Projekt megnyitása a Visual Studióban

Ezután nyissa meg a projektet a Visual Studióban.

1. Indítsa el a Visual Studio 2019-et.
2. Töltse be a projektet, és nyissa meg helloworld.cpp.

Kezdje néhány sablonkóddal

Adjunk hozzá néhány olyan kódot, amely csontvázként működik a projektünkhöz. Vegye figyelembe, hogy létrehozott egy aszinkron metódust.recognizeIntent()

#include "stdafx.h"
#include <iostream>
#include <speechapi_cxx.h>

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

void recognizeIntent()
{

}

int wmain()
{
    try
    {
        recognizeIntent();
    }
    catch (exception e)
    {
        cout << e.what();
    }
    cout << "Please press a key to continue.\n";
    cin.get();
    return 0;
}

Beszédkonfiguráció létrehozása

Mielőtt inicializálhat egy IntentRecognizer objektumot, létre kell hoznia egy konfigurációt, amely a LUIS előrejelzési erőforrás kulcsát és helyét használja.

Fontos

A kezdőkulcs és a szerzői kulcsok nem működnek. A korábban létrehozott előrejelzési kulcsot és helyet kell használnia. További információ: LUIS-alkalmazás létrehozása szándékfelismeréshez.

Szúrja be ezt a kódot a recognizeIntent() metódusba. Győződjön meg arról, hogy frissíti ezeket az értékeket:

• Cserélje le "YourLanguageUnderstandingSubscriptionKey" a LUIS előrejelzési kulcsára.
• Cserélje le "YourLanguageUnderstandingServiceRegion" a LUIS-helyet. Régióazonosító használata a régióból.

Tipp.

Ha segítségre van szüksége ezeknek az értékeknek a megkereséséhez, olvassa el a SZÁNDÉKFELISMERÉSi LUIS-alkalmazás létrehozása című témakört.

Fontos

Ne felejtse el eltávolítani a kulcsot a kódból, amikor elkészült, és soha ne tegye közzé nyilvánosan. Éles környezetben biztonságos módon tárolhatja és érheti el a hitelesítő adatait, például az Azure Key Vaultot. További információkért tekintse meg az Azure AI-szolgáltatások biztonsági cikkét.

auto config = SpeechConfig::FromSubscription(
    "YourLanguageUnderstandingSubscriptionKey",
    "YourLanguageUnderstandingServiceRegion");

Ez a minta a metódust használja a FromSubscription() SpeechConfig. Az elérhető módszerek teljes listáját a SpeechConfig osztályban találja.

A Speech SDK alapértelmezés szerint felismeri az en-us nyelvet. A forrásnyelv kiválasztásával kapcsolatos információkért tekintse meg a Beszéd felismerése című témakört.

IntentRecognizer inicializálása

Most hozzunk létre egy IntentRecognizer. Szúrja be ezt a kódot a recognizeIntent() metódusba, közvetlenül a Speech-konfiguráció alatt.

// Creates an intent recognizer using microphone as audio input.
auto recognizer = IntentRecognizer::FromConfig(config);

LanguageUnderstandingModel és Szándékok hozzáadása

Társítania kell egy LanguageUnderstandingModel szándék-felismerőt, és hozzá kell adnia a felismerni kívánt szándékokat. Az előre összeállított tartomány szándékait fogjuk használni az otthoni automatizáláshoz.

Szúrja be ezt a kódot a saját IntentRecognizeralá. Győződjön meg arról, hogy lecseréli "YourLanguageUnderstandingAppId" a LUIS-alkalmazásazonosítót.

Tipp.

Ha segítségre van szüksége ennek az értéknek a megkereséséhez, olvassa el a LUIS-alkalmazás létrehozása szándékfelismeréshez című témakört.

// Creates a Language Understanding model using the app id, and adds specific intents from your model
auto model = LanguageUnderstandingModel::FromAppId("YourLanguageUnderstandingAppId");
recognizer->AddIntent(model, "YourLanguageUnderstandingIntentName1", "id1");
recognizer->AddIntent(model, "YourLanguageUnderstandingIntentName2", "id2");
recognizer->AddIntent(model, "YourLanguageUnderstandingIntentName3", "any-IntentId-here");

Ez a példa a függvényt AddIntent() használja a szándékok egyéni hozzáadásához. Ha egy modell összes szándékát hozzá szeretné adni, használja AddAllIntents(model) és adja át a modellt.

Szándék felismerése

IntentRecognizer Az objektumból fogja meghívni a metódustRecognizeOnceAsync(). Ez a módszer tudatja a Speech szolgáltatással, hogy egyetlen kifejezést küld a felismeréshez, és hogy a kifejezés azonosítása után a rendszer leállítja a beszéd felismerését. Az egyszerűség kedvéért megvárjuk a jövőt, amíg befejeződik.

Szúrja be ezt a kódot a modell alá:

cout << "Say something...\n";

// Starts intent recognition, and returns after a single utterance is recognized. The end of a
// single utterance is determined by listening for silence at the end or until a maximum of about 30
// seconds of audio is processed.  The task returns the recognition text as result. 
// Note: Since RecognizeOnceAsync() returns only a single utterance, it is suitable only for single
// shot recognition like command or query. 
// For long-running multi-utterance recognition, use StartContinuousRecognitionAsync() instead.
auto result = recognizer->RecognizeOnceAsync().get();

A felismerési eredmények (vagy hibák) megjelenítése

Amikor a Speech szolgáltatás visszaadja a felismerési eredményt, szeretne valamit tenni vele. Egyszerűnek fogjuk tartani, és kinyomtatjuk az eredményt a konzolon.

Szúrja be a következő auto result = recognizer->RecognizeOnceAsync().get();kódot:

// Checks result.
if (result->Reason == ResultReason::RecognizedIntent)
{
    cout << "RECOGNIZED: Text=" << result->Text << std::endl;
    cout << "  Intent Id: " << result->IntentId << std::endl;
    cout << "  Intent Service JSON: " << result->Properties.GetProperty(PropertyId::LanguageUnderstandingServiceResponse_JsonResult) << std::endl;
}
else if (result->Reason == ResultReason::RecognizedSpeech)
{
    cout << "RECOGNIZED: Text=" << result->Text << " (intent could not be recognized)" << std::endl;
}
else if (result->Reason == ResultReason::NoMatch)
{
    cout << "NOMATCH: Speech could not be recognized." << std::endl;
}
else if (result->Reason == 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 update the subscription info?" << std::endl;
    }
}

A kód ellenőrzése

Ezen a ponton a kódnak a következőképpen kell kinéznie:

Feljegyzés

Megjegyzéseket fűztünk ehhez a verzióhoz.

//
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.md file in the project root for full license information.
//

// <skeleton_1>
#include "stdafx.h"
#include <iostream>
#include <speechapi_cxx.h>

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

void recognizeIntent()
{
    // </skeleton_1>
    // Creates an instance of a speech config with specified subscription key
    // and service region. Note that in contrast to other services supported by
    // the Cognitive Services Speech SDK, the Language Understanding service
    // requires a specific subscription key from https://www.luis.ai/.
    // The Language Understanding service calls the required key 'endpoint key'.
    // Once you've obtained it, replace with below with your own Language Understanding subscription key
    // and service region (e.g., "westus").
    // The default recognition language is "en-us".
    // <create_speech_configuration>
    auto config = SpeechConfig::FromSubscription(
        "YourLanguageUnderstandingSubscriptionKey",
        "YourLanguageUnderstandingServiceRegion");
    // </create_speech_configuration>

    // <create_intent_recognizer>
    // Creates an intent recognizer using microphone as audio input.
    auto recognizer = IntentRecognizer::FromConfig(config);
    // </create_intent_recognizer>

    // <add_intents>
    // Creates a Language Understanding model using the app id, and adds specific intents from your model
    auto model = LanguageUnderstandingModel::FromAppId("YourLanguageUnderstandingAppId");
    recognizer->AddIntent(model, "YourLanguageUnderstandingIntentName1", "id1");
    recognizer->AddIntent(model, "YourLanguageUnderstandingIntentName2", "id2");
    recognizer->AddIntent(model, "YourLanguageUnderstandingIntentName3", "any-IntentId-here");
    // </add_intents>

    // To add all of the possible intents from a LUIS model to the recognizer, uncomment the line below:
    // recognizer->AddAllIntents(model);

    // <recognize_intent>
    cout << "Say something...\n";

    // Starts intent recognition, and returns after a single utterance is recognized. The end of a
    // single utterance is determined by listening for silence at the end or until a maximum of about 30
    // seconds of audio is processed.  The task returns the recognition text as result. 
    // Note: Since RecognizeOnceAsync() returns only a single utterance, it is suitable only for single
    // shot recognition like command or query. 
    // For long-running multi-utterance recognition, use StartContinuousRecognitionAsync() instead.
    auto result = recognizer->RecognizeOnceAsync().get();
    // </recognize_intent>

    // <print_results>
    // Checks result.
    if (result->Reason == ResultReason::RecognizedIntent)
    {
        cout << "RECOGNIZED: Text=" << result->Text << std::endl;
        cout << "  Intent Id: " << result->IntentId << std::endl;
        cout << "  Intent Service JSON: " << result->Properties.GetProperty(PropertyId::LanguageUnderstandingServiceResponse_JsonResult) << std::endl;
    }
    else if (result->Reason == ResultReason::RecognizedSpeech)
    {
        cout << "RECOGNIZED: Text=" << result->Text << " (intent could not be recognized)" << std::endl;
    }
    else if (result->Reason == ResultReason::NoMatch)
    {
        cout << "NOMATCH: Speech could not be recognized." << std::endl;
    }
    else if (result->Reason == 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 update the subscription info?" << std::endl;
        }
    }
    // </print_results>
    // <skeleton_2>
}

int wmain()
{
    try
    {
        recognizeIntent();
    }
    catch (exception e)
    {
        cout << e.what();
    }
    cout << "Please press a key to continue.\n";
    cin.get();
    return 0;
}
// </skeleton_2>

Az alkalmazás létrehozása és futtatása

Most már készen áll az alkalmazás összeállítására és a beszédfelismerés tesztelésére a Speech szolgáltatással.

1. A kód fordítása – A Visual Studio menüsávjában válassza a Build Megoldás létrehozása>lehetőséget.
2. Az alkalmazás indítása – A menüsávon válassza a Hibakeresés indítása hibakeresése> lehetőséget, vagy nyomja le az F5 billentyűt.
3. Felismerés indítása – Arra kéri, hogy angol nyelven beszéljen egy kifejezéssel. A rendszer elküldi a beszédet a Speech szolgáltatásnak, átíratja szövegként, és a konzolon jeleníti meg.

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

Ebben a rövid útmutatóban a Speech SDK és a Language Understanding (LUIS) szolgáltatás használatával fogja felismerni a mikrofonból rögzített hangadatok szándékait. Pontosabban a Speech SDK-val fogja rögzíteni a beszédet, és egy előre összeállított tartományt a LUIS-ból az otthoni automatizálás szándékainak azonosításához, például a fény be- és kikapcsolásához.

Előfeltételek

• Azure-előfizetés – Ingyenes létrehozás
• Nyelvi erőforrás létrehozása az Azure Portalon. Az ingyenes tarifacsomag (F0) használatával kipróbálhatja a szolgáltatást, és később frissíthet egy fizetős szintre az éles környezetben. Ezúttal nem lesz szüksége Speech-erőforrásra.
• Szerezze be a language erőforráskulcsot és a régiót. A nyelvi erőforrás üzembe helyezése után válassza az Ugrás az erőforrásra lehetőséget a kulcsok megtekintéséhez és kezeléséhez.

Emellett telepítenie kell a Speech SDK-t a fejlesztői környezethez, és létre kell hoznia egy üres mintaprojektet.

LUIS-alkalmazás létrehozása szándékfelismeréshez

A szándékfelismerés rövid útmutatójának elvégzéséhez létre kell hoznia egy LUIS-fiókot és egy projektet a LUIS előzetes verziójának portálján. Ez a rövid útmutató luis-előfizetést igényel egy olyan régióban, ahol a szándékfelismerés elérhető. A Speech service-előfizetés nem szükséges.

Első lépésként létre kell hoznia egy LUIS-fiókot és -alkalmazást a LUIS előzetes verziójának portálján. A létrehozott LUIS-alkalmazás egy előre összeállított tartományt fog használni az otthoni automatizáláshoz, amely szándékokat, entitásokat és példaszövegeket biztosít. Ha végzett, egy LUIS-végpont fog futni a felhőben, amelyet a Speech SDK használatával hívhat meg.

Kövesse az alábbi utasításokat a LUIS-alkalmazás létrehozásához:

• Rövid útmutató: Előre összeállított tartományi alkalmazás létrehozása

Ha végzett, négy dologra lesz szüksége:

• Ismételt közzététel a Speech Priming kapcsolóval
• A LUIS elsődleges kulcsa
• Az Ön LUIS-helye
• A LUIS-alkalmazás azonosítója

Az alábbi helyen találja ezeket az információkat a LUIS előzetes verziójának portálján:

1. A LUIS előnézeti portálján válassza ki az alkalmazást, majd válassza a Közzététel gombot.

2. Válassza ki az éles pontot, ha a beállítások módosítása lehetőséget használja en-US , és állítsa a Speech priming beállítást a Be állásra. Ezután válassza a Közzététel gombot.

   Fontos

   A beszédfelismerés erősen ajánlott, mivel javítja a beszédfelismerés pontosságát.

   

3. A LUIS előzetes verziós portálján válassza a Kezelés, majd az Azure-erőforrások lehetőséget. Ezen a lapon megtalálja a LUIS-előrejelzési erőforrás LUIS-kulcsát és helyét (más néven régiót).

   

4. Miután megkapta a kulcsot és a helyet, szüksége lesz az alkalmazásazonosítóra. Válassza a Beállítások lehetőséget. az alkalmazásazonosító ezen a lapon érhető el.

   

A projekt megnyitása

1. Nyissa meg a kívánt IDE-t.
2. Töltse be a projektet, és nyissa meg Main.java.

Kezdje néhány sablonkóddal

Adjunk hozzá néhány olyan kódot, amely csontvázként működik a projektünkhöz.

package speechsdk.quickstart;

import com.microsoft.cognitiveservices.speech.*;
import com.microsoft.cognitiveservices.speech.intent.*;

/**
 * Quickstart: recognize speech using the Speech SDK for Java.
 */
public class Main {

    /**
     * @param args Arguments are ignored in this sample.
     */
    public static void main(String[] args) {

        } catch (Exception ex) {
            System.out.println("Unexpected exception: " + ex.getMessage());

            assert(false);
            System.exit(1);
        }
    }
}

Beszédkonfiguráció létrehozása

Mielőtt inicializálhat egy IntentRecognizer objektumot, létre kell hoznia egy konfigurációt, amely a LUIS előrejelzési erőforrás kulcsát és helyét használja.

Szúrja be ezt a kódot a try/catch blokkba.main() Győződjön meg arról, hogy frissíti ezeket az értékeket:

• Cserélje le "YourLanguageUnderstandingSubscriptionKey" a LUIS előrejelzési kulcsára.
• Cserélje le "YourLanguageUnderstandingServiceRegion" a LUIS-helyet. Régióazonosító használata régióból

Tipp.

Ha segítségre van szüksége ezeknek az értékeknek a megkereséséhez, olvassa el a SZÁNDÉKFELISMERÉSi LUIS-alkalmazás létrehozása című témakört.

Fontos

Ne felejtse el eltávolítani a kulcsot a kódból, amikor elkészült, és soha ne tegye közzé nyilvánosan. Éles környezetben biztonságos módon tárolhatja és érheti el a hitelesítő adatait, például az Azure Key Vaultot. További információkért tekintse meg az Azure AI-szolgáltatások biztonsági cikkét.

// Replace below with with specified subscription key (called 'endpoint key' by the Language Understanding service)
String languageUnderstandingSubscriptionKey = "YourLanguageUnderstandingSubscriptionKey";
// Replace below with your own service region (e.g., "westus").
String languageUnderstandingServiceRegion = "YourLanguageUnderstandingServiceRegion";

// Creates an instance of intent recognizer with a given speech configuration.
// Recognizer is created with the default microphone audio input and default language "en-us".
try (SpeechConfig config = SpeechConfig.fromSubscription(languageUnderstandingSubscriptionKey, languageUnderstandingServiceRegion);

Ez a minta a metódust használja a FromSubscription() SpeechConfig. Az elérhető módszerek teljes listáját a SpeechConfig osztályban találja.

A Speech SDK alapértelmezés szerint felismeri az en-us nyelvet. A forrásnyelv kiválasztásával kapcsolatos információkért tekintse meg a Beszéd felismerése című témakört.

IntentRecognizer inicializálása

Most hozzunk létre egy IntentRecognizer. Szúrja be ezt a kódot közvetlenül a Speech-konfiguráció alá.

IntentRecognizer recognizer = new IntentRecognizer(config)) {

LanguageUnderstandingModel és Szándékok hozzáadása

Társítania kell egy LanguageUnderstandingModel szándék-felismerőt, és hozzá kell adnia a felismerni kívánt szándékokat. Az előre összeállított tartomány szándékait fogjuk használni az otthoni automatizáláshoz.

Szúrja be ezt a kódot a saját IntentRecognizeralá. Győződjön meg arról, hogy lecseréli "YourLanguageUnderstandingAppId" a LUIS-alkalmazásazonosítót.

Tipp.

Ha segítségre van szüksége ennek az értéknek a megkereséséhez, olvassa el a LUIS-alkalmazás létrehozása szándékfelismeréshez című témakört.

// Creates a language understanding model using the app id, and adds specific intents from your model
LanguageUnderstandingModel model = LanguageUnderstandingModel.fromAppId("YourLanguageUnderstandingAppId");
recognizer.addIntent(model, "YourLanguageUnderstandingIntentName1", "id1");
recognizer.addIntent(model, "YourLanguageUnderstandingIntentName2", "id2");
recognizer.addIntent(model, "YourLanguageUnderstandingIntentName3", "any-IntentId-here");

Ez a példa a függvényt addIntent() használja a szándékok egyéni hozzáadásához. Ha egy modell összes szándékát hozzá szeretné adni, használja addAllIntents(model) és adja át a modellt.

Szándék felismerése

IntentRecognizer Az objektumból fogja meghívni a metódustrecognizeOnceAsync(). Ez a módszer tudatja a Speech szolgáltatással, hogy egyetlen kifejezést küld a felismeréshez, és hogy a kifejezés azonosítása után a rendszer leállítja a beszéd felismerését.

Szúrja be ezt a kódot a modell alá:

System.out.println("Say something...");

// Starts recognition. It returns when the first utterance has been recognized.
IntentRecognitionResult result = recognizer.recognizeOnceAsync().get();

A felismerési eredmények (vagy hibák) megjelenítése

Amikor a Speech szolgáltatás visszaadja a felismerési eredményt, szeretne valamit tenni vele. Egyszerűnek fogjuk tartani, és kinyomtatjuk az eredményt a konzolon.

Szúrja be ezt a kódot a hívás recognizeOnceAsync()alá.

// Checks result.
if (result.getReason() == ResultReason.RecognizedIntent) {
    System.out.println("RECOGNIZED: Text=" + result.getText());
    System.out.println("    Intent Id: " + result.getIntentId());
    System.out.println("    Intent Service JSON: " + result.getProperties().getProperty(PropertyId.LanguageUnderstandingServiceResponse_JsonResult));
}
else if (result.getReason() == ResultReason.RecognizedSpeech) {
    System.out.println("RECOGNIZED: Text=" + result.getText());
    System.out.println("    Intent not recognized.");
}
else if (result.getReason() == ResultReason.NoMatch) {
    System.out.println("NOMATCH: Speech could not be recognized.");
}
else if (result.getReason() == 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 update the subscription info?");
    }
}

A kód ellenőrzése

Ezen a ponton a kódnak a következőképpen kell kinéznie:

Feljegyzés

Megjegyzéseket fűztünk ehhez a verzióhoz.

//
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.md file in the project root for full license information.
//

// <skeleton_1>
package speechsdk.quickstart;

import com.microsoft.cognitiveservices.speech.*;
import com.microsoft.cognitiveservices.speech.intent.*;

/**
 * Quickstart: recognize speech using the Speech SDK for Java.
 */
public class Main {

    /**
     * @param args Arguments are ignored in this sample.
     */
    public static void main(String[] args) {
    // </skeleton_1>
        // <create_speech_configuration>
        // Replace below with with specified subscription key (called 'endpoint key' by the Language Understanding service)
        String languageUnderstandingSubscriptionKey = "YourLanguageUnderstandingSubscriptionKey";
        // Replace below with your own service region (e.g., "westus").
        String languageUnderstandingServiceRegion = "YourLanguageUnderstandingServiceRegion";

        // Creates an instance of intent recognizer with a given speech configuration.
        // Recognizer is created with the default microphone audio input and default language "en-us".
        try (SpeechConfig config = SpeechConfig.fromSubscription(languageUnderstandingSubscriptionKey, languageUnderstandingServiceRegion);
        // </create_speech_configuration>
            // <create_intent_recognizer>
            IntentRecognizer recognizer = new IntentRecognizer(config)) {
            // </create_intent_recognizer>

            // <add_intents>
            // Creates a language understanding model using the app id, and adds specific intents from your model
            LanguageUnderstandingModel model = LanguageUnderstandingModel.fromAppId("YourLanguageUnderstandingAppId");
            recognizer.addIntent(model, "YourLanguageUnderstandingIntentName1", "id1");
            recognizer.addIntent(model, "YourLanguageUnderstandingIntentName2", "id2");
            recognizer.addIntent(model, "YourLanguageUnderstandingIntentName3", "any-IntentId-here");
            // </add_intents>

            // To add all of the possible intents from a LUIS model to the recognizer, uncomment the line below:
            // recognizer.addAllIntents(model);

            // <recognize_intent>
            System.out.println("Say something...");

            // Starts recognition. It returns when the first utterance has been recognized.
            IntentRecognitionResult result = recognizer.recognizeOnceAsync().get();
            // </recognize_intent>

            // <print_result>
            // Checks result.
            if (result.getReason() == ResultReason.RecognizedIntent) {
                System.out.println("RECOGNIZED: Text=" + result.getText());
                System.out.println("    Intent Id: " + result.getIntentId());
                System.out.println("    Intent Service JSON: " + result.getProperties().getProperty(PropertyId.LanguageUnderstandingServiceResponse_JsonResult));
            }
            else if (result.getReason() == ResultReason.RecognizedSpeech) {
                System.out.println("RECOGNIZED: Text=" + result.getText());
                System.out.println("    Intent not recognized.");
            }
            else if (result.getReason() == ResultReason.NoMatch) {
                System.out.println("NOMATCH: Speech could not be recognized.");
            }
            else if (result.getReason() == 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 update the subscription info?");
                }
            }
            // </print_result>
        // <skeleton_2>
        } catch (Exception ex) {
            System.out.println("Unexpected exception: " + ex.getMessage());

            assert(false);
            System.exit(1);
        }
    }
}
// </skeleton_2>

Az alkalmazás létrehozása és futtatása

Nyomja le az F11 billentyűt, vagy válassza a Hibakeresés futtatása lehetőséget>. A mikrofonból érkező következő 15 másodpercnyi beszédet a rendszer felismeri, és a konzolablakban naplózza.

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

Ebben a rövid útmutatóban a Speech SDK és a Language Understanding (LUIS) szolgáltatás használatával fogja felismerni a mikrofonból rögzített hangadatok szándékait. Pontosabban a Speech SDK-val fogja rögzíteni a beszédet, és egy előre összeállított tartományt a LUIS-ból az otthoni automatizálás szándékainak azonosításához, például a fény be- és kikapcsolásához.

Előfeltételek

• Azure-előfizetés – Ingyenes létrehozás
• Nyelvi erőforrás létrehozása az Azure Portalon. Az ingyenes tarifacsomag (F0) használatával kipróbálhatja a szolgáltatást, és később frissíthet egy fizetős szintre az éles környezetben. Ezúttal nem lesz szüksége Speech-erőforrásra.
• Szerezze be a language erőforráskulcsot és a régiót. A nyelvi erőforrás üzembe helyezése után válassza az Ugrás az erőforrásra lehetőséget a kulcsok megtekintéséhez és kezeléséhez.

Emellett telepítenie kell a Speech SDK-t a fejlesztői környezethez, és létre kell hoznia egy üres mintaprojektet.

LUIS-alkalmazás létrehozása szándékfelismeréshez

A szándékfelismerés rövid útmutatójának elvégzéséhez létre kell hoznia egy LUIS-fiókot és egy projektet a LUIS előzetes verziójának portálján. Ez a rövid útmutató luis-előfizetést igényel egy olyan régióban, ahol a szándékfelismerés elérhető. A Speech service-előfizetés nem szükséges.

Első lépésként létre kell hoznia egy LUIS-fiókot és -alkalmazást a LUIS előzetes verziójának portálján. A létrehozott LUIS-alkalmazás egy előre összeállított tartományt fog használni az otthoni automatizáláshoz, amely szándékokat, entitásokat és példaszövegeket biztosít. Ha végzett, egy LUIS-végpont fog futni a felhőben, amelyet a Speech SDK használatával hívhat meg.

Kövesse az alábbi utasításokat a LUIS-alkalmazás létrehozásához:

• Rövid útmutató: Előre összeállított tartományi alkalmazás létrehozása

Ha végzett, négy dologra lesz szüksége:

• Ismételt közzététel a Speech Priming kapcsolóval
• A LUIS elsődleges kulcsa
• Az Ön LUIS-helye
• A LUIS-alkalmazás azonosítója

Az alábbi helyen találja ezeket az információkat a LUIS előzetes verziójának portálján:

1. A LUIS előnézeti portálján válassza ki az alkalmazást, majd válassza a Közzététel gombot.

2. Válassza ki az éles pontot, ha a beállítások módosítása lehetőséget használja en-US , és állítsa a Speech priming beállítást a Be állásra. Ezután válassza a Közzététel gombot.

   Fontos

   A beszédfelismerés erősen ajánlott, mivel javítja a beszédfelismerés pontosságát.

   

3. A LUIS előzetes verziós portálján válassza a Kezelés, majd az Azure-erőforrások lehetőséget. Ezen a lapon megtalálja a LUIS-előrejelzési erőforrás LUIS-kulcsát és helyét (más néven régiót).

   

4. Miután megkapta a kulcsot és a helyet, szüksége lesz az alkalmazásazonosítóra. Válassza a Beállítások lehetőséget. az alkalmazásazonosító ezen a lapon érhető el.

   

Kezdje néhány sablonkóddal

Adjunk hozzá néhány olyan kódot, amely csontvázként működik a projektünkhöz.

    <!DOCTYPE html>
    <html>
    <head>
    <title>Microsoft Azure AI Speech SDK JavaScript Quickstart</title>
    <meta charset="utf-8" />
    </head>
    <body style="font-family:'Helvetica Neue',Helvetica,Arial,sans-serif; font-size:13px;">
    </body>
    </html>

Felhasználói felület elemeinek hozzáadása

Most hozzáadunk néhány alapszintű felhasználói felületet a beviteli mezőkhöz, hivatkozunk a Speech SDK JavaScript-jára, és szükség esetén beszerezünk egy engedélyezési jogkivonatot.

Fontos

Ne felejtse el eltávolítani a kulcsot a kódból, amikor elkészült, és soha ne tegye közzé nyilvánosan. Éles környezetben biztonságos módon tárolhatja és érheti el a hitelesítő adatait, például az Azure Key Vaultot. További információkért tekintse meg az Azure AI-szolgáltatások biztonsági cikkét.

<body style="font-family:'Helvetica Neue',Helvetica,Arial,sans-serif; font-size:13px;">
  <div id="content" style="display:none">
    <table width="100%">
      <tr>
        <td></td>
        <td><h1 style="font-weight:500;">Microsoft Azure AI Speech SDK JavaScript Quickstart</h1></td>
      </tr>
      <tr>
        <td align="right"><a href="https://learn.microsoft.com/azure/ai-services/speech-service/overview" target="_blank">Subscription</a>:</td>
        <td><input id="subscriptionKey" type="text" size="40" value="subscription"></td>
      </tr>
      <tr>
        <td align="right">Region</td>
        <td><input id="serviceRegion" type="text" size="40" value="YourServiceRegion"></td>
      </tr>
      <tr>
        <td align="right">Application ID:</td>
        <td><input id="appId" type="text" size="60" value="YOUR_LANGUAGE_UNDERSTANDING_APP_ID"></td>
      </tr>
      <tr>
        <td></td>
        <td><button id="startIntentRecognizeAsyncButton">Start Intent Recognition</button></td>
      </tr>
      <tr>
        <td align="right" valign="top">Input Text</td>
        <td><textarea id="phraseDiv" style="display: inline-block;width:500px;height:200px"></textarea></td>
      </tr>
      <tr>
        <td align="right" valign="top">Result</td>
        <td><textarea id="statusDiv" style="display: inline-block;width:500px;height:100px"></textarea></td>
      </tr>
    </table>
  </div>

  <script src="microsoft.cognitiveservices.speech.sdk.bundle.js"></script>

  <script>
  // Note: Replace the URL with a valid endpoint to retrieve
  //       authorization tokens for your subscription.
  var authorizationEndpoint = "token.php";

  function RequestAuthorizationToken() {
    if (authorizationEndpoint) {
      var a = new XMLHttpRequest();
      a.open("GET", authorizationEndpoint);
      a.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
      a.send("");
      a.onload = function() {
				var token = JSON.parse(atob(this.responseText.split(".")[1]));
				serviceRegion.value = token.region;
				authorizationToken = this.responseText;
				subscriptionKey.disabled = true;
				subscriptionKey.value = "using authorization token (hit F5 to refresh)";
				console.log("Got an authorization token: " + token);
      }
    }
  }
  </script>

  <script>
    // status fields and start button in UI
    var phraseDiv;
    var statusDiv;
    var startIntentRecognizeAsyncButton;

    // subscription key, region, and appId for LUIS services.
    var subscriptionKey, serviceRegion, appId;
    var authorizationToken;
    var SpeechSDK;
    var recognizer;

    document.addEventListener("DOMContentLoaded", function () {
      startIntentRecognizeAsyncButton = document.getElementById("startIntentRecognizeAsyncButton");
      subscriptionKey = document.getElementById("subscriptionKey");
      serviceRegion = document.getElementById("serviceRegion");
      appId = document.getElementById("appId");
      phraseDiv = document.getElementById("phraseDiv");
      statusDiv = document.getElementById("statusDiv");

      startIntentRecognizeAsyncButton.addEventListener("click", function () {
        startIntentRecognizeAsyncButton.disabled = true;
        phraseDiv.innerHTML = "";
        statusDiv.innerHTML = "";
      });

      if (!!window.SpeechSDK) {
        SpeechSDK = window.SpeechSDK;
        startIntentRecognizeAsyncButton.disabled = false;

        document.getElementById('content').style.display = 'block';
        document.getElementById('warning').style.display = 'none';

        // in case we have a function for getting an authorization token, call it.
        if (typeof RequestAuthorizationToken === "function") {
          RequestAuthorizationToken();
        }
      }
    });
  </script>

Beszédkonfiguráció létrehozása

Mielőtt inicializálhat egy SpeechRecognizer objektumot, létre kell hoznia egy konfigurációt, amely az előfizetési kulcsot és az előfizetési régiót használja. Szúrja be ezt a kódot a startRecognizeOnceAsyncButton.addEventListener() metódusba.

Feljegyzés

A Speech SDK alapértelmezés szerint felismeri az en-us nyelvet. A forrásnyelv kiválasztásával kapcsolatos információkért tekintse meg a Beszéd felismerése című témakört.

        // if we got an authorization token, use the token. Otherwise use the provided subscription key
        var speechConfig;
        if (authorizationToken) {
          speechConfig = SpeechSDK.SpeechConfig.fromAuthorizationToken(authorizationToken, serviceRegion.value);
        } else {
          if (subscriptionKey.value === "" || subscriptionKey.value === "subscription") {
            alert("Please enter your Microsoft Azure AI Speech subscription key!");
            return;
          }
          startIntentRecognizeAsyncButton.disabled = false;
          speechConfig = SpeechSDK.SpeechConfig.fromSubscription(subscriptionKey.value, serviceRegion.value);
        }

        speechConfig.speechRecognitionLanguage = "en-US";

Hangkonfiguráció létrehozása

Most létre kell hoznia egy AudioConfig objektumot, amely a bemeneti eszközre mutat. Szúrja be ezt a kódot a startIntentRecognizeAsyncButton.addEventListener() metódusba, közvetlenül a Speech-konfiguráció alatt.

        var audioConfig = SpeechSDK.AudioConfig.fromDefaultMicrophoneInput();

IntentRecognizer inicializálása

Most hozzuk létre az IntentRecognizer objektumot a SpeechConfig korábban létrehozott és AudioConfig létrehozott objektumok használatával. Szúrja be ezt a kódot a startIntentRecognizeAsyncButton.addEventListener() metódusba.

        recognizer = new SpeechSDK.IntentRecognizer(speechConfig, audioConfig);

LanguageUnderstandingModel és Szándékok hozzáadása

Társítania kell egy LanguageUnderstandingModel szándék-felismerőt, és hozzá kell adnia a felismerni kívánt szándékokat. Az előre összeállított tartomány szándékait fogjuk használni az otthoni automatizáláshoz.

Szúrja be ezt a kódot a saját IntentRecognizeralá. Győződjön meg arról, hogy lecseréli "YourLanguageUnderstandingAppId" a LUIS-alkalmazásazonosítót.

        if (appId.value !== "" && appId.value !== "YOUR_LANGUAGE_UNDERSTANDING_APP_ID") {
          var lm = SpeechSDK.LanguageUnderstandingModel.fromAppId(appId.value);

          recognizer.addAllIntents(lm);
        }

Feljegyzés

A Speech SDK csak a LUIS 2.0-s végpontjait támogatja. A példalekérdezés mezőben található v3.0-végpont URL-címét manuálisan kell módosítania a v2.0 URL-minta használatához. A LUIS 2.0-s végpontjai mindig az alábbi két minta egyikét követik:

• https://{AzureResourceName}.cognitiveservices.azure.com/luis/v2.0/apps/{app-id}?subscription-key={subkey}&verbose=true&q=
• https://{Region}.api.cognitive.microsoft.com/luis/v2.0/apps/{app-id}?subscription-key={subkey}&verbose=true&q=

Szándék felismerése

IntentRecognizer Az objektumból fogja meghívni a metódustrecognizeOnceAsync(). Ez a módszer tudatja a Speech szolgáltatással, hogy egyetlen kifejezést küld a felismeréshez, és hogy a kifejezés azonosítása után a rendszer leállítja a beszéd felismerését.

Szúrja be ezt a kódot a modell hozzáadása alá:

        recognizer.recognizeOnceAsync(
          function (result) {
            window.console.log(result);

            phraseDiv.innerHTML = result.text + "\r\n";

            statusDiv.innerHTML += "(continuation) Reason: " + SpeechSDK.ResultReason[result.reason];
            switch (result.reason) {
              case SpeechSDK.ResultReason.RecognizedSpeech:
                statusDiv.innerHTML += " Text: " + result.text;
                break;
              case SpeechSDK.ResultReason.RecognizedIntent:
                statusDiv.innerHTML += " Text: " + result.text + " IntentId: " + result.intentId;

                // The actual JSON returned from Language Understanding is a bit more complex to get to, but it is available for things like
                // the entity name and type if part of the intent.
                statusDiv.innerHTML += " Intent JSON: " + result.properties.getProperty(SpeechSDK.PropertyId.LanguageUnderstandingServiceResponse_JsonResult);
                phraseDiv.innerHTML += result.properties.getProperty(SpeechSDK.PropertyId.LanguageUnderstandingServiceResponse_JsonResult) + "\r\n";
                break;
              case SpeechSDK.ResultReason.NoMatch:
                var noMatchDetail = SpeechSDK.NoMatchDetails.fromResult(result);
                statusDiv.innerHTML += " NoMatchReason: " + SpeechSDK.NoMatchReason[noMatchDetail.reason];
                break;
              case SpeechSDK.ResultReason.Canceled:
                var cancelDetails = SpeechSDK.CancellationDetails.fromResult(result);
                statusDiv.innerHTML += " CancellationReason: " + SpeechSDK.CancellationReason[cancelDetails.reason];

              if (cancelDetails.reason === SpeechSDK.CancellationReason.Error) {
                statusDiv.innerHTML += ": " + cancelDetails.errorDetails;
              }
            break;
            }
            statusDiv.innerHTML += "\r\n";
            startIntentRecognizeAsyncButton.disabled = false;
          },
          function (err) {
            window.console.log(err);

            phraseDiv.innerHTML += "ERROR: " + err;
            startIntentRecognizeAsyncButton.disabled = false;
          });

A kód ellenőrzése

<!DOCTYPE html>
<html>
<head>
  <title>Microsoft Cognitive Services Speech SDK JavaScript Quickstart</title>
  <meta charset="utf-8" />
</head>
<body style="font-family:'Helvetica Neue',Helvetica,Arial,sans-serif; font-size:13px;">
  <div id="warning">
    <h1 style="font-weight:500;">Speech Recognition Speech SDK not found (microsoft.cognitiveservices.speech.sdk.bundle.js missing).</h1>
  </div>
  
  <div id="content" style="display:none">
    <table width="100%">
      <tr>
        <td></td>
        <td><h1 style="font-weight:500;">Microsoft Cognitive Services Speech SDK JavaScript Quickstart</h1></td>
      </tr>
      <tr>
        <td align="right"><a href="https://docs.microsoft.com/azure/cognitive-services/speech-service/quickstarts/intent-recognition?pivots=programming-language-csharp#create-a-luis-app-for-intent-recognition" target="_blank">LUIS Primary Key</a>:</td>
        <td><input id="subscriptionKey" type="text" size="40" value="subscription"></td>
      </tr>
      <tr>
        <td align="right">LUIS Location</td>
        <td><input id="serviceRegion" type="text" size="40" value="YourServiceRegion"></td>
      </tr>
      <tr>
        <td align="right">LUIS App ID:</td>
        <td><input id="appId" type="text" size="60" value="YOUR_LANGUAGE_UNDERSTANDING_APP_ID"></td>
      </tr>
      <tr>
        <td></td>
        <td><button id="startIntentRecognizeAsyncButton">Start Intent Recognition</button></td>
      </tr>
      <tr>
        <td align="right" valign="top">Input Text</td>
        <td><textarea id="phraseDiv" style="display: inline-block;width:500px;height:200px"></textarea></td>
      </tr>
      <tr>
        <td align="right" valign="top">Result</td>
        <td><textarea id="statusDiv" style="display: inline-block;width:500px;height:100px"></textarea></td>
      </tr>
    </table>
  </div>

  <!-- Speech SDK reference sdk. -->
  <script src="https://aka.ms/csspeech/jsbrowserpackageraw"></script>

  <!-- Speech SDK USAGE -->
  <script>
    // status fields and start button in UI
    var phraseDiv;
    var statusDiv;
    var startIntentRecognizeAsyncButton;

    // subscription key and region for speech services.
    var subscriptionKey, serviceRegion, appId;
    var SpeechSDK;
    var recognizer;

    document.addEventListener("DOMContentLoaded", function () {

      startIntentRecognizeAsyncButton = document.getElementById("startIntentRecognizeAsyncButton");
      subscriptionKey = document.getElementById("subscriptionKey");
      serviceRegion = document.getElementById("serviceRegion");
      appId = document.getElementById("appId");
      phraseDiv = document.getElementById("phraseDiv");
      statusDiv = document.getElementById("statusDiv");

      startIntentRecognizeAsyncButton.addEventListener("click", function () {
        startIntentRecognizeAsyncButton.disabled = true;
        phraseDiv.innerHTML = "";
        statusDiv.innerHTML = "";

        let audioConfig = SpeechSDK.AudioConfig.fromDefaultMicrophoneInput();
        if (subscriptionKey.value === "" || subscriptionKey.value === "subscription") {
          alert("Please enter your Microsoft Cognitive Services Speech subscription key!");
          startIntentRecognizeAsyncButton.disabled = false;
          return;
        }
        var speechConfig = SpeechSDK.SpeechConfig.fromSubscription(subscriptionKey.value, serviceRegion.value);

        speechConfig.speechRecognitionLanguage = "en-US";
        recognizer = new SpeechSDK.IntentRecognizer(speechConfig, audioConfig);

        // Set up a Language Understanding Model from Language Understanding Intelligent Service (LUIS).
        // See https://www.luis.ai/home for more information on LUIS.
        if (appId.value !== "" && appId.value !== "YOUR_LANGUAGE_UNDERSTANDING_APP_ID") {
          var lm = SpeechSDK.LanguageUnderstandingModel.fromAppId(appId.value);

          recognizer.addAllIntents(lm);
        }

        recognizer.recognizeOnceAsync(
          function (result) {
            window.console.log(result);
            phraseDiv.innerHTML = result.text + "\r\n";

            statusDiv.innerHTML += "(continuation) Reason: " + SpeechSDK.ResultReason[result.reason];
            switch (result.reason) {

              case SpeechSDK.ResultReason.RecognizedSpeech:
                statusDiv.innerHTML += " Text: " + result.text;
                break;

              case SpeechSDK.ResultReason.RecognizedIntent:
                statusDiv.innerHTML += " Text: " + result.text + " IntentId: " + result.intentId;

                // The actual JSON returned from Language Understanding is a bit more complex to get to, but it is available for things like
                // the entity name and type if part of the intent.
                statusDiv.innerHTML += " Intent JSON: " + result.properties.getProperty(SpeechSDK.PropertyId.LanguageUnderstandingServiceResponse_JsonResult);
                phraseDiv.innerHTML += result.properties.getProperty(SpeechSDK.PropertyId.LanguageUnderstandingServiceResponse_JsonResult) + "\r\n";
                break;

              case SpeechSDK.ResultReason.NoMatch:
                var noMatchDetail = SpeechSDK.NoMatchDetails.fromResult(result);
                statusDiv.innerHTML += " NoMatchReason: " + SpeechSDK.NoMatchReason[noMatchDetail.reason];
                break;
                
              case SpeechSDK.ResultReason.Canceled:
                var cancelDetails = SpeechSDK.CancellationDetails.fromResult(result);
                statusDiv.innerHTML += " CancellationReason: " + SpeechSDK.CancellationReason[cancelDetails.reason];

                if (cancelDetails.reason === SpeechSDK.CancellationReason.Error) {
                  statusDiv.innerHTML += ": " + cancelDetails.errorDetails;
                }
                break;
            }
            statusDiv.innerHTML += "\r\n";
            startIntentRecognizeAsyncButton.disabled = false;
          },
          function (err) {
            window.console.log(err);

            phraseDiv.innerHTML += "ERROR: " + err;
            startIntentRecognizeAsyncButton.disabled = false;
        });
      });

      if (!!window.SpeechSDK) {
        SpeechSDK = window.SpeechSDK;
        startIntentRecognizeAsyncButton.disabled = false;

        document.getElementById('content').style.display = 'block';
        document.getElementById('warning').style.display = 'none';
      }
    });

  </script>
</body>
</html>

A jogkivonatforrás létrehozása (nem kötelező)

Ha egy webkiszolgálón szeretné futtatni a weblapot, opcionálisan megadhat egy jogkivonatforrást a bemutató alkalmazáshoz. Így az előfizetői azonosítója soha nem fog kikerülni a kiszolgálóról, közben viszont a felhasználóknak úgy teheti lehetővé a beszédfelismerési képességek használatát, hogy ők maguk semmilyen engedélyezési kódot nem adnak meg.

Hozzon létre egy új fájlt token.php néven. Ebben a példában feltételezzük, hogy a webkiszolgáló támogatja a PHP-szkriptnyelvet a curl engedélyezésével. Írja be a következő kódot:

<?php
header('Access-Control-Allow-Origin: ' . $_SERVER['SERVER_NAME']);

// Replace with your own subscription key and service region (e.g., "westus").
$subscriptionKey = 'YourSubscriptionKey';
$region = 'YourServiceRegion';

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://' . $region . '.api.cognitive.microsoft.com/sts/v1.0/issueToken');
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, '{}');
curl_setopt($ch, CURLOPT_HTTPHEADER, array('Content-Type: application/json', 'Ocp-Apim-Subscription-Key: ' . $subscriptionKey));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
echo curl_exec($ch);
?>

Feljegyzés

Az engedélyezési jogkivonatok csupán korlátozott élettartammal rendelkeznek. Ez az egyszerűsített példa nem mutatja be, hogyan lehet frissíteni az engedélyezési jogkivonatokat. Felhasználóként manuálisan betöltheti az oldalt újból, vagy megnyomhatja az F5 billentyűt a frissítéshez.

A minta helyi buildelése és futtatása

Az alkalmazás elindításához kattintson duplán az index.html fájlra, vagy nyissa meg az index.html fájlt kedvenc webböngészőjében. Ez egy egyszerű grafikus felhasználói felületet jelenít meg, amely lehetővé teszi a LUIS-kulcs, a LUIS-régió és a LUIS-alkalmazásazonosító megadását. Miután megadta ezeket a mezőket, a megfelelő gombra kattintva aktiválhatja a felismerést a mikrofonnal.

Feljegyzés

Ez a módszer nem működik a Safari böngészőben. A Safariban a mintaweblapot egy webkiszolgálón kell üzemeltetni; A Safari nem engedélyezi a helyi fájlból betöltött webhelyeknek a mikrofon használatát.

A minta buildelése és futtatása webkiszolgáló használatával

Az alkalmazás elindításához nyissa meg a kedvenc webböngészőt, és mutasson arra a nyilvános URL-címre, amelyen a mappát üzemelteti, adja meg a LUIS-régiót és a LUIS-alkalmazásazonosítót, és aktiváljon egy felismerést a mikrofonnal. Ha konfigurálva van, jogkivonatot szerez be a jogkivonat forrásától, és megkezdi a beszélt parancsok felismerését.

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

Ebben a rövid útmutatóban a Speech SDK és a Language Understanding (LUIS) szolgáltatás használatával fogja felismerni a mikrofonból rögzített hangadatok szándékait. Pontosabban a Speech SDK-val fogja rögzíteni a beszédet, és egy előre összeállított tartományt a LUIS-ból az otthoni automatizálás szándékainak azonosításához, például a fény be- és kikapcsolásához.

Előfeltételek

• Azure-előfizetés – Ingyenes létrehozás
• Nyelvi erőforrás létrehozása az Azure Portalon. Az ingyenes tarifacsomag (F0) használatával kipróbálhatja a szolgáltatást, és később frissíthet egy fizetős szintre az éles környezetben. Ezúttal nem lesz szüksége Speech-erőforrásra.
• Szerezze be a language erőforráskulcsot és a régiót. A nyelvi erőforrás üzembe helyezése után válassza az Ugrás az erőforrásra lehetőséget a kulcsok megtekintéséhez és kezeléséhez.

Emellett telepítenie kell a Speech SDK-t a fejlesztői környezethez, és létre kell hoznia egy üres mintaprojektet.

LUIS-alkalmazás létrehozása szándékfelismeréshez

A szándékfelismerés rövid útmutatójának elvégzéséhez létre kell hoznia egy LUIS-fiókot és egy projektet a LUIS előzetes verziójának portálján. Ez a rövid útmutató luis-előfizetést igényel egy olyan régióban, ahol a szándékfelismerés elérhető. A Speech service-előfizetés nem szükséges.

Első lépésként létre kell hoznia egy LUIS-fiókot és -alkalmazást a LUIS előzetes verziójának portálján. A létrehozott LUIS-alkalmazás egy előre összeállított tartományt fog használni az otthoni automatizáláshoz, amely szándékokat, entitásokat és példaszövegeket biztosít. Ha végzett, egy LUIS-végpont fog futni a felhőben, amelyet a Speech SDK használatával hívhat meg.

Kövesse az alábbi utasításokat a LUIS-alkalmazás létrehozásához:

• Rövid útmutató: Előre összeállított tartományi alkalmazás létrehozása

Ha végzett, négy dologra lesz szüksége:

• Ismételt közzététel a Speech Priming kapcsolóval
• A LUIS elsődleges kulcsa
• Az Ön LUIS-helye
• A LUIS-alkalmazás azonosítója

Az alábbi helyen találja ezeket az információkat a LUIS előzetes verziójának portálján:

1. A LUIS előnézeti portálján válassza ki az alkalmazást, majd válassza a Közzététel gombot.

2. Válassza ki az éles pontot, ha a beállítások módosítása lehetőséget használja en-US , és állítsa a Speech priming beállítást a Be állásra. Ezután válassza a Közzététel gombot.

   Fontos

   A beszédfelismerés erősen ajánlott, mivel javítja a beszédfelismerés pontosságát.

   

3. A LUIS előzetes verziós portálján válassza a Kezelés, majd az Azure-erőforrások lehetőséget. Ezen a lapon megtalálja a LUIS-előrejelzési erőforrás LUIS-kulcsát és helyét (más néven régiót).

   

4. Miután megkapta a kulcsot és a helyet, szüksége lesz az alkalmazásazonosítóra. Válassza a Beállítások lehetőséget. az alkalmazásazonosító ezen a lapon érhető el.

   

A projekt megnyitása

1. Nyissa meg a kívánt IDE-t.
2. Hozzon létre egy új projektet, és hozzon létre egy nevű quickstart.pyfájlt, majd nyissa meg.

Kezdje néhány sablonkóddal

Adjunk hozzá néhány olyan kódot, amely csontvázként működik a projektünkhöz.

import azure.cognitiveservices.speech as speechsdk

print("Say something...")

Beszédkonfiguráció létrehozása

Mielőtt inicializálhat egy IntentRecognizer objektumot, létre kell hoznia egy konfigurációt, amely a LUIS előrejelzési erőforrás kulcsát és helyét használja.

A kód beszúrása a következőbe quickstart.py: Győződjön meg arról, hogy frissíti ezeket az értékeket:

• Cserélje le "YourLanguageUnderstandingSubscriptionKey" a LUIS előrejelzési kulcsára.
• Cserélje le "YourLanguageUnderstandingServiceRegion" a LUIS-helyet. Régióazonosító használata régióból

Tipp.

Ha segítségre van szüksége ezeknek az értékeknek a megkereséséhez, olvassa el a SZÁNDÉKFELISMERÉSi LUIS-alkalmazás létrehozása című témakört.

Fontos

Ne felejtse el eltávolítani a kulcsot a kódból, amikor elkészült, és soha ne tegye közzé nyilvánosan. Éles környezetben biztonságos módon tárolhatja és érheti el a hitelesítő adatait, például az Azure Key Vaultot. További információkért tekintse meg az Azure AI-szolgáltatások biztonsági cikkét.

# Set up the config for the intent recognizer (remember that this uses the Language Understanding key, not the Speech Services key)!
intent_config = speechsdk.SpeechConfig(
    subscription="YourLanguageUnderstandingSubscriptionKey",
    region="YourLanguageUnderstandingServiceRegion")

Ez a minta LUIS-kulcs és régió használatával hozza létre az SpeechConfig objektumot. Az elérhető módszerek teljes listáját a SpeechConfig osztályban találja.

A Speech SDK alapértelmezés szerint felismeri az en-us nyelvet. A forrásnyelv kiválasztásával kapcsolatos információkért tekintse meg a Beszéd felismerése című témakört.

IntentRecognizer inicializálása

Most hozzunk létre egy IntentRecognizer. Szúrja be ezt a kódot közvetlenül a Speech-konfiguráció alá.

# Set up the intent recognizer
intent_recognizer = speechsdk.intent.IntentRecognizer(speech_config=intent_config)

LanguageUnderstandingModel és Szándékok hozzáadása

Társítania kell egy LanguageUnderstandingModel szándék-felismerőt, és hozzá kell adnia a felismerni kívánt szándékokat. Az előre összeállított tartomány szándékait fogjuk használni az otthoni automatizáláshoz.

Szúrja be ezt a kódot a saját IntentRecognizeralá. Győződjön meg arról, hogy lecseréli "YourLanguageUnderstandingAppId" a LUIS-alkalmazásazonosítót.

Tipp.

Ha segítségre van szüksége ennek az értéknek a megkereséséhez, olvassa el a LUIS-alkalmazás létrehozása szándékfelismeréshez című témakört.

# set up the intents that are to be recognized. These can be a mix of simple phrases and
# intents specified through a LanguageUnderstanding Model.
model = speechsdk.intent.LanguageUnderstandingModel(app_id="YourLanguageUnderstandingAppId")
intents = [
    (model, "HomeAutomation.TurnOn"),
    (model, "HomeAutomation.TurnOff"),
    ("This is a test.", "test"),
    ("Switch to channel 34.", "34"),
    ("what's the weather like", "weather"),
]
intent_recognizer.add_intents(intents)

Ez a példa a függvény használatával add_intents() adja hozzá a explicit módon definiált szándékok listáját. Ha egy modell összes szándékát hozzá szeretné adni, használja add_all_intents(model) és adja át a modellt.

Szándék felismerése

IntentRecognizer Az objektumból fogja meghívni a metódustrecognize_once(). Ez a módszer tudatja a Speech szolgáltatással, hogy egyetlen kifejezést küld a felismeréshez, és hogy a kifejezés azonosítása után a rendszer leállítja a beszéd felismerését.

Szúrja be ezt a kódot a modell alá.

intent_result = intent_recognizer.recognize_once()

A felismerési eredmények (vagy hibák) megjelenítése

Amikor a Speech szolgáltatás visszaadja a felismerési eredményt, szeretne valamit tenni vele. Egyszerűnek fogjuk tartani, és kinyomtatjuk az eredményt a konzolon.

A hívás recognize_once()alatt adja hozzá ezt a kódot.

# Check the results
if intent_result.reason == speechsdk.ResultReason.RecognizedIntent:
    print("Recognized: \"{}\" with intent id `{}`".format(intent_result.text, intent_result.intent_id))
elif intent_result.reason == speechsdk.ResultReason.RecognizedSpeech:
    print("Recognized: {}".format(intent_result.text))
elif intent_result.reason == speechsdk.ResultReason.NoMatch:
    print("No speech could be recognized: {}".format(intent_result.no_match_details))
elif intent_result.reason == speechsdk.ResultReason.Canceled:
    print("Intent recognition canceled: {}".format(intent_result.cancellation_details.reason))
    if intent_result.cancellation_details.reason == speechsdk.CancellationReason.Error:
        print("Error details: {}".format(intent_result.cancellation_details.error_details))

A kód ellenőrzése

Ezen a ponton a kódnak így kell kinéznie.

Feljegyzés

Megjegyzéseket fűztünk ehhez a verzióhoz.

# Copyright (c) Microsoft. All rights reserved.
# Licensed under the MIT license. See LICENSE.md file in the project root for full license information.

# <skeleton>
import azure.cognitiveservices.speech as speechsdk

print("Say something...")
# </skeleton>

"""performs one-shot intent recognition from input from the default microphone"""

# <create_speech_configuration>
# Set up the config for the intent recognizer (remember that this uses the Language Understanding key, not the Speech Services key)!
intent_config = speechsdk.SpeechConfig(
    subscription="YourLanguageUnderstandingSubscriptionKey",
    region="YourLanguageUnderstandingServiceRegion")
# </create_speech_configuration>

# <create_intent_recognizer>
# Set up the intent recognizer
intent_recognizer = speechsdk.intent.IntentRecognizer(speech_config=intent_config)
# </create_intent_recognizer>

# <add_intents>
# set up the intents that are to be recognized. These can be a mix of simple phrases and
# intents specified through a LanguageUnderstanding Model.
model = speechsdk.intent.LanguageUnderstandingModel(app_id="YourLanguageUnderstandingAppId")
intents = [
    (model, "HomeAutomation.TurnOn"),
    (model, "HomeAutomation.TurnOff"),
    ("This is a test.", "test"),
    ("Switch to channel 34.", "34"),
    ("what's the weather like", "weather"),
]
intent_recognizer.add_intents(intents)
# </add_intents>

# To add all of the possible intents from a LUIS model to the recognizer, uncomment the line below:
# intent_recognizer.add_all_intents(model)

# Starts intent recognition, and returns after a single utterance is recognized. The end of a
# single utterance is determined by listening for silence at the end or until a maximum of about 30
# seconds of audio is processed. It returns the recognition text as result.
# Note: Since recognize_once() returns only a single utterance, it is suitable only for single
# shot recognition like command or query.
# For long-running multi-utterance recognition, use start_continuous_recognition() instead.
# <recognize_intent>
intent_result = intent_recognizer.recognize_once()
# </recognize_intent>

# <print_results>
# Check the results
if intent_result.reason == speechsdk.ResultReason.RecognizedIntent:
    print("Recognized: \"{}\" with intent id `{}`".format(intent_result.text, intent_result.intent_id))
elif intent_result.reason == speechsdk.ResultReason.RecognizedSpeech:
    print("Recognized: {}".format(intent_result.text))
elif intent_result.reason == speechsdk.ResultReason.NoMatch:
    print("No speech could be recognized: {}".format(intent_result.no_match_details))
elif intent_result.reason == speechsdk.ResultReason.Canceled:
    print("Intent recognition canceled: {}".format(intent_result.cancellation_details.reason))
    if intent_result.cancellation_details.reason == speechsdk.CancellationReason.Error:
        print("Error details: {}".format(intent_result.cancellation_details.error_details))
# </print_results>

Az alkalmazás létrehozása és futtatása

Futtassa a mintát a konzolról vagy az IDE-ben:

python quickstart.py

A mikrofonból érkező következő 15 másodpercnyi beszédet a rendszer felismeri, és a konzolablakban naplózza.

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

A Speech SDK for Go nem támogatja a szándékfelismerést. Válasszon egy másik programozási nyelvet, vagy a Go referenciát és a cikk elejétől csatolt mintákat.

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

Az Objective-C-hez készült Speech SDK támogatja a szándékfelismerést, de itt még nem tartalmaztunk útmutatót. Válasszon egy másik programozási nyelvet az első lépésekhez, és ismerje meg a fogalmakat, vagy tekintse meg a cikk elején hivatkozott Objective-C referenciát és mintákat.

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

A Swifthez készült Speech SDK támogatja a szándékfelismerést, de itt még nem tartalmaztunk útmutatót. Válasszon egy másik programozási nyelvet az első lépésekhez, és ismerje meg a fogalmakat, vagy tekintse meg a swift-hivatkozást és a cikk elején hivatkozott mintákat.

Speech to text REST API reference | Speech to text REST API for short audio reference | További minták a GitHubon

A REST API-t használhatja a szándékfelismeréshez, de még nem tartalmaztunk útmutatót. Az első lépésekhez és a fogalmak megismeréséhez válasszon egy másik programozási nyelvet.

A Speech parancssori felülete (CLI) támogatja a szándékfelismerést, de itt még nem tartalmaztunk útmutatót. Az első lépésekhez válasszon egy másik programozási nyelvet, és ismerje meg a fogalmakat, vagy tekintse meg a Speech CLI áttekintését a parancssori felületről.

Következő lépések

További LUIS-minták megtekintése a GitHubon