Självstudier: Identifiera avsikter från tal med hjälp av Speech SDK för C#Tutorial: Recognize intents from speech using the Speech SDK for C#

Cognitive Services Speech SDK integreras med language Understanding-tjänsten (Luis) för att ge avsikts igenkänning.The Cognitive Services Speech SDK integrates with the Language Understanding service (LUIS) to provide intent recognition. En avsikt är något som användaren vill göra: boka en flygning, titta på vädret eller ringa ett samtal.An intent is something the user wants to do: book a flight, check the weather, or make a call. Användaren kan använda de termer som känns naturliga.The user can use whatever terms feel natural. Med Machine Learning kan LUIS mappa användar förfrågningar till de avsikter som du har definierat.Using machine learning, LUIS maps user requests to the intents you've defined.

Anteckning

Ett LUIS-programmet definierar avsikter och entiteter som du vill identifiera.A LUIS application defines the intents and entities you want to recognize. Det är separat från det C#-program som använder Speech-tjänsten.It's separate from the C# application that uses the Speech service. I den här artikeln betyder ”app” LUIS-appen medan ”program” innebär C#-koden.In this article, "app" means the LUIS app, while "application" means the C# code.

I den här självstudien använder du Speech SDK för att utveckla ett C#-konsolprogram som härleder avsikter från användaryttranden via enhetens mikrofon.In this tutorial, you use the Speech SDK to develop a C# console application that derives intents from user utterances through your device's microphone. Du lär dig följande:You'll learn how to:

  • Skapa ett Visual Studio-projekt som refererar till Speech SDK NuGet-paketetCreate a Visual Studio project referencing the Speech SDK NuGet package
  • Skapa en tal konfiguration och få en avsikts igenkänningCreate a speech configuration and get an intent recognizer
  • Hämta modellen för LUIS-appen och lägga till de avsikter som du behöverGet the model for your LUIS app and add the intents you need
  • Ange språk för taligenkänningSpecify the language for speech recognition
  • Identifiera tal från en filRecognize speech from a file
  • Använd asynkron, händelsedriven kontinuerlig igenkänningUse asynchronous, event-driven continuous recognition

FörutsättningarPrerequisites

Se till att du har följande saker innan du påbörjar den här självstudien:Be sure you have the following items before you begin this tutorial:

LUIS och talLUIS and speech

LUIS integreras med tal tjänsterna för att identifiera avsikter från tal.LUIS integrates with the Speech Services to recognize intents from speech. Du behöver inte en prenumerations tjänst prenumeration, bara LUIS.You don't need a Speech Services subscription, just LUIS.

LUIS använder två typer av nycklar:LUIS uses two kinds of keys:

NyckeltypKey type SyftePurpose
RedigeringAuthoring Gör att du kan skapa och ändra LUIS-appar program mässigtLets you create and modify LUIS apps programmatically
SlutpunktEndpoint Auktoriserar åtkomst till en viss LUIS-appAuthorizes access to a particular LUIS app

För den här självstudien behöver du slut punkts nyckel typen.For this tutorial, you need the endpoint key type. I självstudien används exempel programmet Home Automation LUIS, som du kan skapa genom att följa snabb starten för välbyggda hem automatiserings program .The tutorial uses the example Home Automation LUIS app, which you can create by following the Use prebuilt Home automation app quickstart. Om du har skapat en LUIS app som du själv har skapat kan du använda den i stället.If you've created a LUIS app of your own, you can use it instead.

När du skapar en LUIS-app genererar LUIS automatiskt en start nyckel så att du kan testa appen med hjälp av text frågor.When you create a LUIS app, LUIS automatically generates a starter key so you can test the app using text queries. Den här nyckeln aktiverar inte integrering av tal tjänster och fungerar inte med den här självstudien.This key doesn't enable the Speech Services integration and won't work with this tutorial. Skapa en LUIS-resurs på Azure-instrumentpanelen och tilldela den till LUIS-appen.Create a LUIS resource in the Azure dashboard and assign it to the LUIS app. Du kan använda den kostnadsfria prenumerationsnivån för den här självstudiekursen.You can use the free subscription tier for this tutorial.

När du har skapat LUIS-resursen på Azure-instrumentpanelen loggar du in på Luis-portalen, väljer ditt program på sidan Mina appar och växlar sedan till appens hanterings sida.After you create the LUIS resource in the Azure dashboard, log into the LUIS portal, choose your application on the My Apps page, then switch to the app's Manage page. Slutligen väljer du nycklar och slut punkter i sido panelen.Finally, select Keys and Endpoints in the sidebar.

LUIS-portalens inställningar för nycklar och slutpunkter

På sidan nycklar och inställningar för slut punkt :On the Keys and Endpoint settings page:

  1. Rulla ned till avsnittet resurser och nycklar och välj tilldela resurs.Scroll down to the Resources and Keys section and select Assign resource.

  2. Gör följande ändringar i dialog rutan tilldela en nyckel till din app :In the Assign a key to your app dialog box, make the following changes:

    • Under klientväljer du Microsoft.Under Tenant, choose Microsoft.
    • Under prenumerations namnväljer du den Azure-prenumeration som innehåller den Luis-resurs som du vill använda.Under Subscription Name, choose the Azure subscription that contains the LUIS resource you want to use.
    • Under nyckelväljer du den Luis-resurs som du vill använda med appen.Under Key, choose the LUIS resource that you want to use with the app.

    Om en stund visas den nya prenumerationen i tabellen längst ned på sidan.In a moment, the new subscription appears in the table at the bottom of the page.

  3. Välj ikonen bredvid en tangent för att kopiera den till Urklipp.Select the icon next to a key to copy it to the clipboard. (Du kan använda valfri nyckel.)(You may use either key.)

Prenumerationsnycklar för LUIS-app

Skapa ett talprojekt i Visual StudioCreate a speech project in Visual Studio

Om du vill skapa ett Visual Studio-projekt för Windows-utveckling måste du skapa projektet, konfigurera Visual Studio för .NET Desktop Development, installera Speech SDK och välja mål arkitektur.To create a Visual Studio project for Windows development, you need to create the project, set up Visual Studio for .NET desktop development, install the Speech SDK, and choose the target architecture.

Skapa projektet och Lägg till arbets belastningenCreate the project and add the workload

Starta genom att skapa projektet i Visual Studio och se till att Visual Studio har kon figurer ATS för .NET Desktop-utveckling:To start, create the project in Visual Studio, and make sure that Visual Studio is set up for .NET desktop development:

  1. Öppna Visual Studio 2019.Open Visual Studio 2019.

  2. I fönstret Starta väljer du skapa ett nytt projekt.In the Start window, select Create a new project.

  3. Välj konsol program (.NET Framework) i fönstret skapa ett nytt projekt och välj sedan Nästa.In the Create a new project window, choose Console App (.NET Framework), and then select Next.

  4. I fönstret Konfigurera ditt nya projekt anger du HelloWorld i projekt namn, väljer eller skapar sökvägen till katalogen på platsenoch väljer sedan skapa.In the Configure your new project window, enter helloworld in Project name, choose or create the directory path in Location, and then select Create.

  5. I meny raden i Visual Studio väljer du verktyg > Hämta verktyg och funktionersom öppnar Visual Studio Installer och visar dialog rutan ändra .From the Visual Studio menu bar, select Tools > Get Tools and Features, which opens Visual Studio Installer and displays the Modifying dialog box.

  6. Kontrol lera om arbets belastningen .net Desktop Development är tillgänglig.Check whether the .NET desktop development workload is available. Om arbets belastningen inte har installerats markerar du kryss rutan bredvid den och väljer sedan ändra för att starta installationen.If the workload hasn't been installed, select the check box next to it, and then select Modify to start the installation. Det kan ta några minuter att ladda ned och installera.It may take a few minutes to download and install.

    Om kryss rutan bredvid .net Desktop Development redan är markerad väljer du Stäng för att stänga dialog rutan.If the check box next to .NET desktop development is already selected, select Close to exit the dialog box.

    Aktivera .NET-skrivbordsutveckling

  7. Stäng Visual Studio Installer.Close Visual Studio Installer.

Installera Speech SDKInstall the Speech SDK

Nästa steg är att installera NuGet- paketet för tal-SDKså att du kan referera till det i koden.The next step is to install the Speech SDK NuGet package, so you can reference it in the code.

  1. I Solution Explorer högerklickar du på projektet HelloWorld och väljer sedan Hantera NuGet-paket för att Visa NuGet Package Manager.In the Solution Explorer, right-click the helloworld project, and then select Manage NuGet Packages to show the NuGet Package Manager.

    NuGet Package Manager

  2. Leta upp List rutan paket källa i det övre högra hörnet och kontrol lera att NuGet.org är markerat.In the upper-right corner, find the Package Source drop-down box, and make sure that nuget.org is selected.

  3. I det övre vänstra hörnet väljer du Bläddra.In the upper-left corner, select Browse.

  4. Skriv Microsoft. CognitiveServices. Speech i rutan Sök och välj RETUR.In the search box, type Microsoft.CognitiveServices.Speech and select Enter.

  5. Från Sök resultaten väljer du paketet Microsoft. CognitiveServices. Speech och väljer sedan Installera för att installera den senaste stabila versionen.From the search results, select the Microsoft.CognitiveServices.Speech package, and then select Install to install the latest stable version.

    Installera Microsoft. CognitiveServices. Speech NuGet-paketet

  6. Acceptera alla avtal och licenser för att starta installationen.Accept all agreements and licenses to start the installation.

    När paketet har installerats visas en bekräftelse i fönstret Package Manager-konsol .After the package is installed, a confirmation appears in the Package Manager Console window.

Välj mål arkitekturChoose the target architecture

Skapa och kör konsol programmet nu genom att skapa en plattforms konfiguration som matchar datorns arkitektur.Now, to build and run the console application, create a platform configuration matching your computer's architecture.

  1. Välj build > Configuration Managerpå Meny raden.From the menu bar, select Build > Configuration Manager. Den Configuration Manager dialogrutan visas.The Configuration Manager dialog box appears.

    Configuration Manager dialog ruta

  2. I list rutan aktiv lösnings plattform väljer du ny.In the Active solution platform drop-down box, select New. Dialog rutan ny lösnings plattform visas.The New Solution Platform dialog box appears.

  3. I list rutan Skriv eller Välj ny plattform :In the Type or select the new platform drop-down box:

    • Om du kör 64-bitars Windows väljer du x64.If you're running 64-bit Windows, select x64.
    • Om du kör 32-bitars Windows väljer du x86.If you're running 32-bit Windows, select x86.
  4. Välj OK och sedan Stäng.Select OK and then Close.

Lägga till kodenAdd the code

Sedan lägger du till kod i projektet.Next, you add code to the project.

  1. Öppna filen program.csfrån Solution Explorer.From Solution Explorer, open the file Program.cs.

  2. Ersätt blocket med using-instruktioner i början av filen med följande deklarationer:Replace the block of using statements at the beginning of the file with the following declarations:

    using System;
    using System.Threading.Tasks;
    using Microsoft.CognitiveServices.Speech;
    using Microsoft.CognitiveServices.Speech.Audio;
    using Microsoft.CognitiveServices.Speech.Intent;
    
  3. I den angivna Main()-metoden lägger du till följande kod:Inside the provided Main() method, add the following code:

    RecognizeIntentAsync().Wait();
    Console.WriteLine("Please press Enter to continue.");
    Console.ReadLine();
    
  4. Skapa en tom asynkron metod RecognizeIntentAsync(), som du ser här:Create an empty asynchronous method RecognizeIntentAsync(), as shown here:

    static async Task RecognizeIntentAsync()
    {
    }
    
  5. I den här nya metodens brödtext lägger du till följande kod:In the body of this new method, add this code:

    // 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".
    var config = SpeechConfig.FromSubscription("YourLanguageUnderstandingSubscriptionKey", "YourLanguageUnderstandingServiceRegion");
    
    // Creates an intent recognizer using microphone as audio input.
    using (var recognizer = new IntentRecognizer(config))
    {
        // 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");
    
        // 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 15
        // 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().ConfigureAwait(false);
    
        // Checks result.
        if (result.Reason == ResultReason.RecognizedIntent)
        {
            Console.WriteLine($"RECOGNIZED: Text={result.Text}");
            Console.WriteLine($"    Intent Id: {result.IntentId}.");
            Console.WriteLine($"    Language Understanding JSON: {result.Properties.GetProperty(PropertyId.LanguageUnderstandingServiceResponse_JsonResult)}.");
        }
        else if (result.Reason == ResultReason.RecognizedSpeech)
        {
            Console.WriteLine($"RECOGNIZED: Text={result.Text}");
            Console.WriteLine($"    Intent not recognized.");
        }
        else if (result.Reason == ResultReason.NoMatch)
        {
            Console.WriteLine($"NOMATCH: Speech could not be recognized.");
        }
        else if (result.Reason == 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?");
            }
        }
    }
    
  6. Ersätt platshållarna i den här metoden med din LUIS-prenumerationsnyckel, region och app-ID på följande sätt.Replace the placeholders in this method with your LUIS subscription key, region, and app ID as follows.

    PlatshållarePlaceholder Ersätt medReplace with
    YourLanguageUnderstandingSubscriptionKey Din LUIS-slutpunktsnyckel.Your LUIS endpoint key. Återigen måste du hämta det här objektet från Azure-instrumentpanelen, inte en "Start nyckel".Again, you must get this item from your Azure dashboard, not a "starter key." Du hittar den på sidan nycklar och slut punkter för appen (under Hantera) i Luis-portalen.You can find it on your app's Keys and Endpoints page (under Manage) in the LUIS portal.
    YourLanguageUnderstandingServiceRegion Den korta identifieraren för den region som din LUIS-prenumeration är i, till exempel westus för USA, västra.The short identifier for the region your LUIS subscription is in, such as westus for West US. Se regioner.See Regions.
    YourLanguageUnderstandingAppId LUIS-app-ID.The LUIS app ID. Du hittar den på appens inställnings sida på Luis- portalen.You can find it on your app's Settings page in the LUIS portal.

När dessa ändringar har gjorts kan du skapa (CTRL + SHIFT + B) och köra (F5) själv studie programmet.With these changes made, you can build (Control+Shift+B) and run (F5) the tutorial application. När du uppmanas kan du prova att säga "Stäng av ljuset" i DATORns mikrofon.When you're prompted, try saying "Turn off the lights" into your PC's microphone. Programmet visar resultatet i konsol fönstret.The application displays the result in the console window.

Följande avsnitt innehåller en beskrivning av koden.The following sections include a discussion of the code.

Skapa en avsiktsigenkännareCreate an intent recognizer

Först måste du skapa en tal konfiguration från LUIS slut punkts nyckel och region.First, you need to create a speech configuration from your LUIS endpoint key and region. Du kan använda tal konfigurationer för att skapa igenkänningar för de olika funktionerna i tal-SDK: n.You can use speech configurations to create recognizers for the various capabilities of the Speech SDK. Tal konfigurationen har flera olika sätt att ange den prenumeration som du vill använda. här använder vi FromSubscription, som tar prenumerations nyckeln och regionen.The speech configuration has multiple ways to specify the subscription you want to use; here, we use FromSubscription, which takes the subscription key and region.

Anteckning

Använd nyckel och region för din LUIS-prenumeration, inte en prenumeration på tal tjänster.Use the key and region of your LUIS subscription, not of a Speech Services subscription.

Nästa steg är att skapa en avsiktsigenkännare med hjälp av new IntentRecognizer(config).Next, create an intent recognizer using new IntentRecognizer(config). Eftersom konfigurationen redan vet vilken prenumeration som ska användas, behöver du inte ange prenumerations nyckeln och slut punkten igen när du skapar tolken.Since the configuration already knows which subscription to use, you don't need to specify the subscription key and endpoint again when creating the recognizer.

Importera en LUIS-modell och lägga till avsikterImport a LUIS model and add intents

Nu importerar du modellen från LUIS-appen med hjälp av LanguageUnderstandingModel.FromAppId() och lägger till de LUIS-avsikter som du vill känna igen igenkännarens AddIntent()-metod.Now import the model from the LUIS app using LanguageUnderstandingModel.FromAppId() and add the LUIS intents that you wish to recognize via the recognizer's AddIntent() method. De här två stegen förbättrar taligenkänningens noggrannhet genom att ange ord som det är troligt att användaren använder i sina begäranden.These two steps improve the accuracy of speech recognition by indicating words that the user is likely to use in their requests. Du behöver inte lägga till alla appens avsikter om du inte behöver känna igen dem i ditt program.You don't have to add all the app's intents if you don't need to recognize them all in your application.

Om du vill lägga till avsikter måste du ange tre argument: LUIS-modellen (som har skapats och heter model), namnet på avsikten och ett avsikts-ID.To add intents, you must provide three arguments: the LUIS model (which has been created and is named model), the intent name, and an intent ID. Skillnaden mellan ID och namnet är som följer.The difference between the ID and the name is as follows.

AddIntent() @ no__t-1argumentAddIntent() argument SyftePurpose
intentNameintentName Namnet på avsikten enligt vad som definierats i LUIS-appen.The name of the intent as defined in the LUIS app. Det här värdet måste matcha namnet på LUIS-avsikten exakt.This value must match the LUIS intent name exactly.
intentIDintentID Ett ID som tilldelas till en igenkänd avsikt av Speech SDK.An ID assigned to a recognized intent by the Speech SDK. Det här värdet kan vara vad du vill. Det behöver inte motsvara det namn på avsikten som definierats i LUIS-appen.This value can be whatever you like; it doesn't need to correspond to the intent name as defined in the LUIS app. Om flera avsikter till exempel hanteras av samma kod kan du använda samma ID för dem.If multiple intents are handled by the same code, for instance, you could use the same ID for them.

LUIS-appen för hem automatisering har två avsikter: en för att aktivera en enhet och en annan för att stänga av en enhet.The Home Automation LUIS app has two intents: one for turning on a device, and another for turning off a device. Raderna nedan lägger till dessa avsikter till igenkännaren. Ersätt de tre AddIntent-raderna i metoden RecognizeIntentAsync() med den här koden.The lines below add these intents to the recognizer; replace the three AddIntent lines in the RecognizeIntentAsync() method with this code.

recognizer.AddIntent(model, "HomeAutomation.TurnOff", "off");
recognizer.AddIntent(model, "HomeAutomation.TurnOn", "on");

I stället för att lägga till enskilda avsikter kan du också använda metoden AddAllIntents för att lägga till alla syften i en modell i igenkännings verktyget.Instead of adding individual intents, you can also use the AddAllIntents method to add all the intents in a model to the recognizer.

Starta igenkänningStart recognition

När igenkännaren har skapats och avsikterna lagts till kan igenkänningen börja.With the recognizer created and the intents added, recognition can begin. Speech SDK stöder både engångsigenkänning och kontinuerlig igenkänning.The Speech SDK supports both single-shot and continuous recognition.

IgenkänningslägeRecognition mode Metoder att anropaMethods to call ResultatResult
EngångsigenkänningSingle-shot RecognizeOnceAsync() Returnerar den igenkända avsikten, om sådan finns, efter ett yttrande.Returns the recognized intent, if any, after one utterance.
KontinuerligContinuous StartContinuousRecognitionAsync()
StopContinuousRecognitionAsync()
Känner igen flera yttranden; genererar händelser (till exempel IntermediateResultReceived) när det finns tillgängliga resultat.Recognizes multiple utterances; emits events (for example, IntermediateResultReceived) when results are available.

Självstudieprogrammet använder engångsigenkänning och anropar därför RecognizeOnceAsync() för att påbörja igenkänning.The tutorial application uses single-shot mode and so calls RecognizeOnceAsync() to begin recognition. Resultatet är ett IntentRecognitionResult-objekt som innehåller information om den igenkända avsikten.The result is an IntentRecognitionResult object containing information about the intent recognized. Du extraherar LUIS JSON-svaret med hjälp av följande uttryck:You extract the LUIS JSON response by using the following expression:

result.Properties.GetProperty(PropertyId.LanguageUnderstandingServiceResponse_JsonResult)

Själv studie kursen går inte att parsa JSON-resultatet.The tutorial application doesn't parse the JSON result. Den visar bara JSON-texten i konsol fönstret.It only displays the JSON text in the console window.

Resultat för enkel LUIS-igenkänning

Ange igenkänningsspråkSpecify recognition language

Som standard känner LUIS igen avsikter på amerikansk engelska (en-us).By default, LUIS recognizes intents in US English (en-us). Genom att tilldela en kod för nationella inställningar till egenskapen SpeechRecognitionLanguage i talkonfigurationen kan du känna igen avsikter på andra språk.By assigning a locale code to the SpeechRecognitionLanguage property of the speech configuration, you can recognize intents in other languages. Lägg exempelvis till config.SpeechRecognitionLanguage = "de-de"; i självstudieprogrammet innan du skapar igenkännaren om du vill känna igen avsikter på tyska.For example, add config.SpeechRecognitionLanguage = "de-de"; in our tutorial application before creating the recognizer to recognize intents in German. Mer information finns i språk som stöds.For more information, see Supported Languages.

Kontinuerlig igenkänning från en filContinuous recognition from a file

Följande kod illustrerar två ytterligare funktioner för avsiktsigenkänning med hjälp av Speech SDK.The following code illustrates two additional capabilities of intent recognition using the Speech SDK. Den första, som nämnts tidigare, är kontinuerlig igenkänning, där igenkännaren genererar händelser när resultat finns tillgängliga.The first, previously mentioned, is continuous recognition, where the recognizer emits events when results are available. Dessa händelser kan sedan bearbetas av händelsehanterare som du anger.These events can then be processed by event handlers that you provide. Med kontinuerlig igenkänning anropar du tolkens StartContinuousRecognitionAsync()-metod för att starta igenkänning i stället för RecognizeOnceAsync().With continuous recognition, you call the recognizer's StartContinuousRecognitionAsync() method to start recognition instead of RecognizeOnceAsync().

Den andra funktionen är att läsa det ljud som innehåller det tal som ska bearbetas från en WAV-fil.The other capability is reading the audio containing the speech to be processed from a WAV file. Implementeringen innebär att skapa en ljud konfiguration som kan användas när du skapar typen av avsikts igenkänning.Implementation involves creating an audio configuration that can be used when creating the intent recognizer. Filen måste vara enkanalig (mono) med en samplingsfrekvens på 16 kHz.The file must be single-channel (mono) with a sampling rate of 16 kHz.

Om du vill testa dessa funktioner tar du bort eller kommenterar innehållet i metoden RecognizeIntentAsync() och lägger till följande kod i sitt ställe.To try out these features, delete or comment out the body of the RecognizeIntentAsync() method, and add the following code in its place.

// 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").
var config = SpeechConfig.FromSubscription("YourLanguageUnderstandingSubscriptionKey", "YourLanguageUnderstandingServiceRegion");

// Creates an intent recognizer using file as audio input.
// Replace with your own audio file name.
using (var audioInput = AudioConfig.FromWavFileInput("whatstheweatherlike.wav"))
{
    using (var recognizer = new IntentRecognizer(config, audioInput))
    {
        // The TaskCompletionSource to stop recognition.
        var stopRecognition = new TaskCompletionSource<int>();

        // 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");

        // Subscribes to events.
        recognizer.Recognizing += (s, e) => {
            Console.WriteLine($"RECOGNIZING: Text={e.Result.Text}");
        };

        recognizer.Recognized += (s, e) => {
            if (e.Result.Reason == ResultReason.RecognizedIntent)
            {
                Console.WriteLine($"RECOGNIZED: Text={e.Result.Text}");
                Console.WriteLine($"    Intent Id: {e.Result.IntentId}.");
                Console.WriteLine($"    Language Understanding JSON: {e.Result.Properties.GetProperty(PropertyId.LanguageUnderstandingServiceResponse_JsonResult)}.");
            }
            else if (e.Result.Reason == ResultReason.RecognizedSpeech)
            {
                Console.WriteLine($"RECOGNIZED: Text={e.Result.Text}");
                Console.WriteLine($"    Intent not recognized.");
            }
            else if (e.Result.Reason == ResultReason.NoMatch)
            {
                Console.WriteLine($"NOMATCH: Speech could not be recognized.");
            }
        };

        recognizer.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 update the subscription info?");
            }

            stopRecognition.TrySetResult(0);
        };

        recognizer.SessionStarted += (s, e) => {
            Console.WriteLine("\n    Session started event.");
        };

        recognizer.SessionStopped += (s, e) => {
            Console.WriteLine("\n    Session stopped event.");
            Console.WriteLine("\nStop recognition.");
            stopRecognition.TrySetResult(0);
        };


        // Starts continuous recognition. Uses StopContinuousRecognitionAsync() to stop recognition.
        Console.WriteLine("Say something...");
        await recognizer.StartContinuousRecognitionAsync().ConfigureAwait(false);

        // Waits for completion.
        // Use Task.WaitAny to keep the task rooted.
        Task.WaitAny(new[] { stopRecognition.Task });

        // Stops recognition.
        await recognizer.StopContinuousRecognitionAsync().ConfigureAwait(false);
    }
}

Ändra koden så att den innehåller din LUIS-slutpunktsnyckel, region och app-ID för att lägga till Home Automation-avsikterna som tidigare.Revise the code to include your LUIS endpoint key, region, and app ID and to add the Home Automation intents, as before. Ändra whatstheweatherlike.wav till namnet på den inspelade ljud filen.Change whatstheweatherlike.wav to the name of your recorded audio file. Sedan kan du skapa, kopiera ljud filen till build-katalogen och köra programmet.Then build, copy the audio file to the build directory, and run the application.

Om du t. ex. säger att "Stäng av ljuset", pausar och sedan "slå på lamporna" i din inspelade ljud fil, kan konsolens utdata som liknar följande visas:For example, if you say "Turn off the lights", pause, and then say "Turn on the lights" in your recorded audio file, console output similar to the following may appear:

LUIS igenkännings resultat för ljud filen

Hämtar du exemplenGet the samples

Senaste exempel finns i Cognitive Services tal SDK lagringsplatsen för exemplet på GitHub.For the latest samples, see the Cognitive Services Speech SDK sample code repository on GitHub.

Sök efter koden från den här artikeln i mappen samples/csharp/sharedcontent/Console .Look for the code from this article in the samples/csharp/sharedcontent/console folder.

Nästa stegNext steps