Szybki start: biblioteki klienta usługi Language Understanding (LUIS) i interfejs API REST

Ważne

Usługa LUIS zostanie wycofana 1 października 2025 r. i od 1 kwietnia 2023 r. nie będzie można utworzyć nowych zasobów usługi LUIS. Zalecamy migrację aplikacji LUIS do interpretacji języka konwersacyjnego, aby korzystać z ciągłej pomocy technicznej i wielojęzycznych możliwości produktów.

Tworzenie i wykonywanie zapytań względem aplikacji sztucznej inteligencji (AI) usługi Azure LUIS przy użyciu bibliotek klienckich zestawu SDK usługi LUIS, korzystając z tego przewodnika Szybki start przy użyciu języka C#, Python lub JavaScript. Możesz również użyć biblioteki cURL do wysyłania żądań przy użyciu interfejsu API REST.

Usługa Language Understanding (LUIS) umożliwia stosowanie przetwarzania języka naturalnego (NLP) do konwersacji użytkownika, tekstu w języku naturalnym w celu przewidywania ogólnego znaczenia i wyciągania odpowiednich szczegółowych informacji.

• Tworzenie biblioteki klienta i interfejsu API REST umożliwia tworzenie, edytowanie, trenowanie i publikowanie aplikacji usługi LUIS.
• Biblioteka klienta środowiska przewidywania i interfejs API REST umożliwiają wykonywanie zapytań dotyczących opublikowanej aplikacji.

Użyj bibliotek klienckich usługi Language Understanding (LUIS) dla platformy .NET, aby:

• Utwórz aplikację
• Dodawanie intencji, jednostki wyuczonej maszynowo z przykładową wypowiedzią
• Trenowanie i publikowanie aplikacji
• Środowisko uruchomieniowe przewidywania zapytania

Dokumentacja referencyjna | : Tworzenie i kod źródłowy biblioteki przewidywania | Tworzenie i przewidywanie nuGet | Przykład w języku C#

Wymagania wstępne

• Bieżąca wersja interfejsu wiersza polecenia platformy .NET Core i platformy .NET Core.
• Subskrypcja platformy Azure — utwórz bezpłatnie
• Po utworzeniu subskrypcji platformy Azure utwórz zasób tworzenia usługi Language Understanding w witrynie Azure Portal, aby uzyskać klucz i punkt końcowy. Poczekaj na wdrożenie i kliknij przycisk Przejdź do zasobu .
  • Będziesz potrzebować klucza i punktu końcowego z utworzonego zasobu, aby połączyć aplikację z tworzeniem usługi Language Understanding. W dalszej części przewodnika Szybki start wklejesz klucz i punkt końcowy do poniższego kodu. Aby wypróbować usługę, możesz użyć bezpłatnej warstwy cenowej (F0).

Konfigurowanie

Tworzenie nowej aplikacji w języku C#

Utwórz nową aplikację platformy .NET Core w preferowanym edytorze lub środowisku IDE.

1. W oknie konsoli (takim jak cmd, PowerShell lub Bash) użyj polecenia dotnet new , aby utworzyć nową aplikację konsolową o nazwie language-understanding-quickstart. To polecenie tworzy prosty projekt języka C# "Hello World" z jednym plikiem źródłowym: Program.cs.

   dotnet new console -n language-understanding-quickstart
   

2. Zmień katalog na nowo utworzony folder aplikacji.

   cd language-understanding-quickstart
   

3. Aplikację można skompilować za pomocą następujących funkcji:

   dotnet build
   

   Dane wyjściowe kompilacji nie powinny zawierać żadnych ostrzeżeń ani błędów.

   ...
   Build succeeded.
    0 Warning(s)
    0 Error(s)
   ...
   

Instalowanie bibliotek NuGet

W katalogu aplikacji zainstaluj biblioteki klienta usługi Language Understanding (LUIS) dla platformy .NET przy użyciu następujących poleceń:

dotnet add package Microsoft.Azure.CognitiveServices.Language.LUIS.Authoring --version 3.2.0-preview.3
dotnet add package Microsoft.Azure.CognitiveServices.Language.LUIS.Runtime --version 3.1.0-preview.1

Tworzenie modelu obiektów

Klient tworzenia usługi Language Understanding (LUIS) to obiekt LUISAuthoringClient , który uwierzytelnia się na platformie Azure, który zawiera klucz tworzenia.

Przykłady kodu do tworzenia

Po utworzeniu klienta użyj tego klienta, aby uzyskać dostęp do funkcji, w tym:

• Aplikacje — tworzenie, usuwanie, publikowanie
• Przykładowe wypowiedzi — dodawanie, usuwanie według identyfikatora
• Funkcje — zarządzanie listami fraz
• Model — zarządzanie intencjami i jednostkami
• Wzorzec — zarządzanie wzorcami
• Trenowanie — szkolenie aplikacji i sondowania pod kątem stanu trenowania
• Wersje — zarządzanie za pomocą klonowania, eksportowania i usuwania

Model obiektu przewidywania

Klient środowiska uruchomieniowego przewidywania usługi Language Understanding (LUIS) to obiekt LUISRuntimeClient , który uwierzytelnia się na platformie Azure, który zawiera klucz zasobu.

Przykłady kodu dla środowiska uruchomieniowego przewidywania

Po utworzeniu klienta użyj tego klienta, aby uzyskać dostęp do funkcji, w tym:

• Przewidywanie według miejsca przejściowego lub produkcyjnego
• Przewidywanie według wersji

Przykłady kodu

Te fragmenty kodu pokazują, jak wykonać następujące czynności za pomocą biblioteki klienta usługi Language Understanding (LUIS) dla języka Python:

• Tworzenie aplikacji
• Dodawanie intencji
• Dodawanie jednostek
• Dodawanie przykładowych wypowiedzi
• Trenowanie aplikacji
• Publikowanie aplikacji
• Przewidywanie według miejsca

Dodawanie zależności

W katalogu projektu otwórz plik Program.cs w preferowanym edytorze lub środowisku IDE. Zastąp istniejący using kod następującymi using dyrektywami:

using System;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.Azure.CognitiveServices.Language.LUIS.Authoring;
using Microsoft.Azure.CognitiveServices.Language.LUIS.Authoring.Models;
using Microsoft.Azure.CognitiveServices.Language.LUIS.Runtime;
using Microsoft.Azure.CognitiveServices.Language.LUIS.Runtime.Models;
using Newtonsoft.Json;

Dodawanie kodu kociołowego

1. Zmień sygnaturę Main metody, aby zezwolić na wywołania asynchroniczne:

   public static async Task Main()
   

2. Dodaj pozostałą część kodu w Main metodzie Program klasy, chyba że określono inaczej.

Tworzenie zmiennych dla aplikacji

Utwórz dwa zestawy zmiennych: pierwszy zestaw, który zostanie zmieniony, drugi zestaw pozostawi się tak, jak są wyświetlane w przykładzie kodu.

Ważne

Pamiętaj, aby usunąć klucz z kodu po zakończeniu i nigdy nie publikować go publicznie. W przypadku środowiska produkcyjnego użyj bezpiecznego sposobu przechowywania i uzyskiwania dostępu do poświadczeń, takich jak usługa Azure Key Vault. Aby uzyskać więcej informacji, zobacz artykuł Dotyczący zabezpieczeń usług Azure AI.

1. Utwórz zmienne do przechowywania klucza tworzenia i nazw zasobów.

   var key = "PASTE_YOUR_LUIS_AUTHORING_SUBSCRIPTION_KEY_HERE";
   
   var authoringEndpoint = "PASTE_YOUR_LUIS_AUTHORING_ENDPOINT_HERE";
   var predictionEndpoint = "PASTE_YOUR_LUIS_PREDICTION_ENDPOINT_HERE";
   

2. Utwórz zmienne do przechowywania punktów końcowych, nazwy aplikacji, wersji i nazwy intencji.

   var appName = "Contoso Pizza Company";
   var versionId = "0.1";
   var intentName = "OrderPizzaIntent";
   

Uwierzytelnianie użytkownika

Utwórz obiekt ApiKeyServiceClientCredentials przy użyciu klucza i użyj go z punktem końcowym, aby utworzyć obiekt LUISAuthoringClient.

var credentials = new Microsoft.Azure.CognitiveServices.Language.LUIS.Authoring.ApiKeyServiceClientCredentials(key);
var client = new LUISAuthoringClient(credentials) { Endpoint = authoringEndpoint };

Tworzenie aplikacji usługi LUIS

Aplikacja LUIS zawiera model przetwarzania języka naturalnego (NLP), w tym intencje, jednostki i przykładowe wypowiedzi.

Utwórz obiekt ApplicationCreateObject. Wymagane są właściwości nazwy i kultury językowej. Wywołaj metodę Apps.AddAsync . Odpowiedź to identyfikator aplikacji.

var newApp = new ApplicationCreateObject
{
    Culture = "en-us",
    Name = appName,
    InitialVersionId = versionId
};

var appId = await client.Apps.AddAsync(newApp);

Tworzenie intencji dla aplikacji

Podstawowym obiektem w modelu aplikacji usługi LUIS jest intencja. Intencja jest zgodna z grupowaniem intencji wypowiedzi użytkownika. Użytkownik może zadać pytanie lub utworzyć instrukcję wyszukując określoną odpowiedź z bota (lub innej aplikacji klienckiej). Przykłady intencji to rezerwacja lotu, proszenie o pogodę w docelowym mieście i proszenie o informacje kontaktowe dla obsługi klienta.

Utwórz obiekt ModelCreateObject o nazwie unikatowej intencji, a następnie przekaż identyfikator aplikacji, identyfikator wersji i obiekt ModelCreateObject do metody Model.AddIntentAsync . Odpowiedź to identyfikator intencji.

Wartość intentName jest trwale zakodowana jako OrderPizzaIntent część zmiennych w sekcji Tworzenie zmiennych dla aplikacji .

await client.Model.AddIntentAsync(appId, versionId, new ModelCreateObject()
{
    Name = intentName
});

Tworzenie jednostek dla aplikacji

Chociaż jednostki nie są wymagane, znajdują się w większości aplikacji. Jednostka wyodrębnia informacje z wypowiedzi użytkownika, niezbędne do pełnego filtrowania intencji użytkownika. Istnieje kilka typów wstępnie utworzonych i niestandardowych jednostek, z których każdy ma własne modele obiektu przekształcania danych (DTO). Typowe wstępnie utworzone jednostki do dodania do aplikacji obejmują liczbę, datę/godzinaV2, geografięV2 lub porządkową.

Ważne jest, aby wiedzieć, że jednostki nie są oznaczone intencją. Mogą one i zwykle mają zastosowanie do wielu intencji. Tylko przykładowe wypowiedzi użytkownika są oznaczone dla określonej, pojedynczej intencji.

Metody tworzenia jednostek są częścią klasy Model . Każdy typ jednostki ma własny model obiektu przekształcania danych (DTO), zwykle zawierający wyraz model w przestrzeni nazw Modele .

Kod tworzenia jednostki tworzy jednostkę uczenia maszynowego z jednostkami podrzędnymi i funkcjami zastosowanymi do Quantity podentiencji.

// Add Prebuilt entity
await client.Model.AddPrebuiltAsync(appId, versionId, new[] { "number" });

// Define ml entity with children and grandchildren
var mlEntityDefinition = new EntityModelCreateObject
{
    Name = "Pizza order",
    Children = new[]
    {
        new ChildEntityModelCreateObject
        {
            Name = "Pizza",
            Children = new[]
            {
                new ChildEntityModelCreateObject { Name = "Quantity" },
                new ChildEntityModelCreateObject { Name = "Type" },
                new ChildEntityModelCreateObject { Name = "Size" }
            }
        },
        new ChildEntityModelCreateObject
        {
            Name = "Toppings",
            Children = new[]
            {
                new ChildEntityModelCreateObject { Name = "Type" },
                new ChildEntityModelCreateObject { Name = "Quantity" }
            }
        }
    }
};

// Add ML entity 
var mlEntityId = await client.Model.AddEntityAsync(appId, versionId, mlEntityDefinition); ;

// Add phraselist feature
var phraselistId = await client.Features.AddPhraseListAsync(appId, versionId, new PhraselistCreateObject
{
    EnabledForAllModels = false,
    IsExchangeable = true,
    Name = "QuantityPhraselist",
    Phrases = "few,more,extra"
});

// Get entity and subentities
var model = await client.Model.GetEntityAsync(appId, versionId, mlEntityId);
var toppingQuantityId = GetModelGrandchild(model, "Toppings", "Quantity");
var pizzaQuantityId = GetModelGrandchild(model, "Pizza", "Quantity");

// add model as feature to subentity model
await client.Features.AddEntityFeatureAsync(appId, versionId, pizzaQuantityId, new ModelFeatureInformation { ModelName = "number", IsRequired = true });
await client.Features.AddEntityFeatureAsync(appId, versionId, toppingQuantityId, new ModelFeatureInformation { ModelName = "number"});

// add phrase list as feature to subentity model
await client.Features.AddEntityFeatureAsync(appId, versionId, toppingQuantityId, new ModelFeatureInformation { FeatureName = "QuantityPhraselist" });

Użyj następującej metody do klasy, aby znaleźć identyfikator podentulności Quantity, aby przypisać funkcje do tej podentyjności.

static Guid GetModelGrandchild(NDepthEntityExtractor model, string childName, string grandchildName)
{
    return model.Children.
        Single(c => c.Name == childName).
        Children.
        Single(c => c.Name == grandchildName).Id;
}

Dodawanie przykładowej wypowiedzi do intencji

Aby określić intencję wypowiedzi i wyodrębnić jednostki, aplikacja potrzebuje przykładów wypowiedzi. Przykłady muszą być przeznaczone dla określonej, pojedynczej intencji i powinny oznaczać wszystkie jednostki niestandardowe. Wstępnie utworzone jednostki nie muszą być oznaczone.

Dodaj przykładowe wypowiedzi, tworząc listę obiektów ExampleLabelObject , jeden obiekt dla każdej przykładowej wypowiedzi. Każdy przykład powinien oznaczać wszystkie jednostki ze słownikiem par nazwa/wartość jednostki i wartości jednostki. Wartość jednostki powinna być dokładnie tak, jak jest wyświetlana w tekście przykładowej wypowiedzi.

Wywołaj metodę Examples.AddAsync przy użyciu identyfikatora aplikacji, identyfikatora wersji i przykładu.

// Define labeled example
var labeledExampleUtteranceWithMLEntity = new ExampleLabelObject
{
    Text = "I want two small seafood pizzas with extra cheese.",
    IntentName = intentName,
    EntityLabels = new[]
    {
        new EntityLabelObject
        {
            StartCharIndex = 7,
            EndCharIndex = 48,
            EntityName = "Pizza order",
            Children = new[]
            {
                new EntityLabelObject
                {
                    StartCharIndex = 7,
                    EndCharIndex = 30,
                    EntityName = "Pizza",
                    Children = new[]
                    {
                        new EntityLabelObject { StartCharIndex = 7, EndCharIndex = 9, EntityName = "Quantity" },
                        new EntityLabelObject { StartCharIndex = 11, EndCharIndex = 15, EntityName = "Size" },
                        new EntityLabelObject { StartCharIndex = 17, EndCharIndex = 23, EntityName = "Type" }
                    }
                },
                new EntityLabelObject
                {
                    StartCharIndex = 37,
                    EndCharIndex = 48,
                    EntityName = "Toppings",
                    Children = new[]
                    {
                        new EntityLabelObject { StartCharIndex = 37, EndCharIndex = 41, EntityName = "Quantity" },
                        new EntityLabelObject { StartCharIndex = 43, EndCharIndex = 48, EntityName = "Type" }
                    }
                }
            }
        },
    }
};

// Add an example for the entity.
// Enable nested children to allow using multiple models with the same name.
// The quantity subentity and the phraselist could have the same exact name if this is set to True
await client.Examples.AddAsync(appId, versionId, labeledExampleUtteranceWithMLEntity, enableNestedChildren: true); 

Uczenie aplikacji

Po utworzeniu modelu należy wytrenować aplikację usługi LUIS dla tej wersji modelu. Wytrenowany model może być używany w kontenerze lub publikowany w miejscach przejściowych lub produktowych.

Metoda Train.TrainVersionAsync wymaga identyfikatora aplikacji i identyfikatora wersji.

Bardzo mały model, taki jak pokazano w tym przewodniku Szybki start, będzie trenował bardzo szybko. W przypadku aplikacji na poziomie produkcyjnym trenowanie aplikacji powinno zawierać wywołanie sondowania do metody GetStatusAsync , aby określić, kiedy lub czy trenowanie zakończyło się pomyślnie. Odpowiedź to lista obiektów ModelTrainingInfo z oddzielnym stanem dla każdego obiektu. Wszystkie obiekty muszą zakończyć się pomyślnie, aby trenowanie zostało uznane za ukończone.

await client.Train.TrainVersionAsync(appId, versionId);
while (true)
{
    var status = await client.Train.GetStatusAsync(appId, versionId);
    if (status.All(m => m.Details.Status == "Success"))
    {
        // Assumes that we never fail, and that eventually we'll always succeed.
        break;
    }
}

Publikowanie aplikacji w miejscu produkcyjnym

Opublikuj aplikację usługi LUIS przy użyciu metody PublishAsync . Spowoduje to opublikowanie bieżącej wytrenowanego wersji do określonego miejsca w punkcie końcowym. Aplikacja kliencka używa tego punktu końcowego do wysyłania wypowiedzi użytkownika na potrzeby przewidywania intencji i wyodrębniania jednostek.

await client.Apps.PublishAsync(appId, new ApplicationPublishObject { VersionId = versionId, IsStaging=false});

Uwierzytelnianie klienta środowiska uruchomieniowego przewidywania

Użyj obiektu ApiKeyServiceClientCredentials z kluczem i użyj go z punktem końcowym, aby utworzyć obiekt LUISRuntimeClient.

Uwaga

Ten przewodnik Szybki start używa klucza tworzenia w ramach poświadczeń środowiska uruchomieniowego. Klucz tworzenia może wykonywać zapytania względem środowiska uruchomieniowego za pomocą kilku zapytań. W przypadku kodu przejściowego i produkcyjnego zastąp klucz tworzenia kluczem środowiska uruchomieniowego przewidywania.

var runtimeClient = new LUISRuntimeClient(credentials) { Endpoint = predictionEndpoint };

Pobieranie przewidywania ze środowiska uruchomieniowego

Dodaj następujący kod, aby utworzyć żądanie do środowiska uruchomieniowego przewidywania.

Wypowiedź użytkownika jest częścią obiektu PredictionRequest .

Metoda GetSlotPredictionAsync wymaga kilku parametrów, takich jak identyfikator aplikacji, nazwa miejsca, obiekt żądania przewidywania w celu spełnienia żądania. Inne opcje, takie jak pełne, pokaż wszystkie intencje i dziennik, są opcjonalne.

// Production == slot name
var request = new PredictionRequest { Query = "I want two small pepperoni pizzas with more salsa" };
var prediction = await runtimeClient.Prediction.GetSlotPredictionAsync(appId, "Production", request);
Console.Write(JsonConvert.SerializeObject(prediction, Formatting.Indented));

Odpowiedź przewidywania to obiekt JSON, w tym intencja i wszystkie znalezione jednostki.

{
    "query": "I want two small pepperoni pizzas with more salsa",
    "prediction": {
        "topIntent": "OrderPizzaIntent",
        "intents": {
            "OrderPizzaIntent": {
                "score": 0.753606856
            },
            "None": {
                "score": 0.119097039
            }
        },
        "entities": {
            "Pizza order": [
                {
                    "Pizza": [
                        {
                            "Quantity": [
                                2
                            ],
                            "Type": [
                                "pepperoni"
                            ],
                            "Size": [
                                "small"
                            ],
                            "$instance": {
                                "Quantity": [
                                    {
                                        "type": "builtin.number",
                                        "text": "two",
                                        "startIndex": 7,
                                        "length": 3,
                                        "score": 0.968156934,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ],
                                "Type": [
                                    {
                                        "type": "Type",
                                        "text": "pepperoni",
                                        "startIndex": 17,
                                        "length": 9,
                                        "score": 0.9345611,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ],
                                "Size": [
                                    {
                                        "type": "Size",
                                        "text": "small",
                                        "startIndex": 11,
                                        "length": 5,
                                        "score": 0.9592077,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ]
                            }
                        }
                    ],
                    "Toppings": [
                        {
                            "Type": [
                                "salsa"
                            ],
                            "Quantity": [
                                "more"
                            ],
                            "$instance": {
                                "Type": [
                                    {
                                        "type": "Type",
                                        "text": "salsa",
                                        "startIndex": 44,
                                        "length": 5,
                                        "score": 0.7292897,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ],
                                "Quantity": [
                                    {
                                        "type": "Quantity",
                                        "text": "more",
                                        "startIndex": 39,
                                        "length": 4,
                                        "score": 0.9320932,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ]
                            }
                        }
                    ],
                    "$instance": {
                        "Pizza": [
                            {
                                "type": "Pizza",
                                "text": "two small pepperoni pizzas",
                                "startIndex": 7,
                                "length": 26,
                                "score": 0.812199831,
                                "modelTypeId": 1,
                                "modelType": "Entity Extractor",
                                "recognitionSources": [
                                    "model"
                                ]
                            }
                        ],
                        "Toppings": [
                            {
                                "type": "Toppings",
                                "text": "more salsa",
                                "startIndex": 39,
                                "length": 10,
                                "score": 0.7250252,
                                "modelTypeId": 1,
                                "modelType": "Entity Extractor",
                                "recognitionSources": [
                                    "model"
                                ]
                            }
                        ]
                    }
                }
            ],
            "$instance": {
                "Pizza order": [
                    {
                        "type": "Pizza order",
                        "text": "two small pepperoni pizzas with more salsa",
                        "startIndex": 7,
                        "length": 42,
                        "score": 0.769223332,
                        "modelTypeId": 1,
                        "modelType": "Entity Extractor",
                        "recognitionSources": [
                            "model"
                        ]
                    }
                ]
            }
        }
    }
}

Uruchamianie aplikacji

Uruchom aplikację za pomocą dotnet run polecenia z katalogu aplikacji.

dotnet run

Użyj bibliotek klienckich usługi Language Understanding (LUIS) dla Node.js, aby:

• Utwórz aplikację
• Dodawanie intencji, jednostki wyuczonej maszynowo z przykładową wypowiedzią
• Trenowanie i publikowanie aplikacji
• Środowisko uruchomieniowe przewidywania zapytania

Dokumentacja referencyjna tworzenia i przewidywania npm przewidywania | | Próbki

Wymagania wstępne

• Node.js
• Subskrypcja platformy Azure — utwórz bezpłatnie
• Po utworzeniu subskrypcji platformy Azure utwórz zasób tworzenia usługi Language Understanding w witrynie Azure Portal, aby uzyskać klucz i punkt końcowy. Poczekaj na wdrożenie i kliknij przycisk Przejdź do zasobu .
  • Będziesz potrzebować klucza i punktu końcowego z utworzonego zasobu, aby połączyć aplikację z tworzeniem usługi Language Understanding. W dalszej części przewodnika Szybki start wklejesz klucz i punkt końcowy do poniższego kodu. Aby wypróbować usługę, możesz użyć bezpłatnej warstwy cenowej (F0).

Konfigurowanie

Tworzenie nowej aplikacji JavaScript

1. W oknie konsoli utwórz nowy katalog dla aplikacji i przejdź do tego katalogu.

   mkdir quickstart-sdk && cd quickstart-sdk
   

2. Zainicjuj katalog jako aplikację JavaScript, tworząc package.json plik.

   npm init -y
   

3. Utwórz plik o nazwie index.js dla kodu JavaScript.

   touch index.js
   

Instalowanie bibliotek NPM

W katalogu aplikacji zainstaluj zależności przy użyciu następujących poleceń, wykonując jeden wiersz jednocześnie:

npm install @azure/ms-rest-js
npm install @azure/cognitiveservices-luis-authoring
npm install @azure/cognitiveservices-luis-runtime

Powinien package.json wyglądać następująco:

{
  "name": "quickstart-sdk",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "@azure/cognitiveservices-luis-authoring": "^4.0.0-preview.3",
    "@azure/cognitiveservices-luis-runtime": "^5.0.0",
    "@azure/ms-rest-js": "^2.0.8"
  }
}

Tworzenie modelu obiektów

Klient tworzenia usługi Language Understanding (LUIS) to obiekt LUISAuthoringClient , który uwierzytelnia się na platformie Azure, który zawiera klucz tworzenia.

Przykłady kodu do tworzenia

Po utworzeniu klienta użyj tego klienta, aby uzyskać dostęp do funkcji, w tym:

• Aplikacje — dodawanie, usuwanie, publikowanie
• Przykładowe wypowiedzi — dodawanie według partii, usuwanie według identyfikatora
• Funkcje — zarządzanie listami fraz
• Model — zarządzanie intencjami i jednostkami
• Wzorzec — zarządzanie wzorcami
• Trenowanie — szkolenie aplikacji i sondowania pod kątem stanu trenowania
• Wersje — zarządzanie za pomocą klonowania, eksportowania i usuwania

Model obiektu przewidywania

Klient tworzenia usługi Language Understanding (LUIS) to obiekt LUISAuthoringClient , który uwierzytelnia się na platformie Azure, który zawiera klucz tworzenia.

Przykłady kodu dla środowiska uruchomieniowego przewidywania

Po utworzeniu klienta użyj tego klienta, aby uzyskać dostęp do funkcji, w tym:

• Przewidywanie według staging miejsca lub production
• Przewidywanie według wersji

Przykłady kodu

Te fragmenty kodu pokazują, jak wykonać następujące czynności za pomocą biblioteki klienta usługi Language Understanding (LUIS) dla języka Python:

• Tworzenie aplikacji
• Dodawanie intencji
• Dodawanie jednostek
• Dodawanie przykładowych wypowiedzi
• Trenowanie aplikacji
• Publikowanie aplikacji
• Przewidywanie według miejsca

Dodawanie zależności

index.js Otwórz plik w preferowanym edytorze lub środowisku IDE o nazwie , a następnie dodaj następujące zależności.

const msRest = require("@azure/ms-rest-js");
const LUIS_Authoring = require("@azure/cognitiveservices-luis-authoring");
const LUIS_Prediction = require("@azure/cognitiveservices-luis-runtime");

Dodawanie kodu kociołowego

1. Dodaj metodę quickstart i jej wywołanie. Ta metoda przechowuje większość pozostałego kodu. Ta metoda jest wywoływana na końcu pliku.

   const quickstart = async () => {
   
       // add calls here
   
   
   }
   quickstart()
       .then(result => console.log("Done"))
       .catch(err => {
           console.log(`Error: ${err}`)
           })
   

2. Dodaj pozostały kod w metodzie Szybkiego startu, chyba że określono inaczej.

Tworzenie zmiennych dla aplikacji

Utwórz dwa zestawy zmiennych: pierwszy zestaw, który zostanie zmieniony, drugi zestaw pozostawi się tak, jak są wyświetlane w przykładzie kodu.

Ważne

Pamiętaj, aby usunąć klucz z kodu po zakończeniu i nigdy nie publikować go publicznie. W przypadku środowiska produkcyjnego użyj bezpiecznego sposobu przechowywania i uzyskiwania dostępu do poświadczeń, takich jak usługa Azure Key Vault. Aby uzyskać więcej informacji, zobacz artykuł Dotyczący zabezpieczeń usług Azure AI.

1. Utwórz zmienne do przechowywania klucza tworzenia i nazw zasobów.

   const authoringKey = 'PASTE_YOUR_LUIS_AUTHORING_SUBSCRIPTION_KEY_HERE';
   
   const authoringEndpoint = "PASTE_YOUR_LUIS_AUTHORING_ENDPOINT_HERE";
   const predictionEndpoint = "PASTE_YOUR_LUIS_PREDICTION_ENDPOINT_HERE";
   

2. Utwórz zmienne do przechowywania punktów końcowych, nazwy aplikacji, wersji i nazwy intencji.

   const appName = "Contoso Pizza Company";
   const versionId = "0.1";
   const intentName = "OrderPizzaIntent";
   

Uwierzytelnianie użytkownika

Utwórz obiekt CognitiveServicesCredentials przy użyciu klucza i użyj go z punktem końcowym, aby utworzyć obiekt LUISAuthoringClient.

const luisAuthoringCredentials = new msRest.ApiKeyCredentials({
    inHeader: { "Ocp-Apim-Subscription-Key": authoringKey }
});
const client = new LUIS_Authoring.LUISAuthoringClient(
    luisAuthoringCredentials,
    authoringEndpoint
);

Tworzenie aplikacji usługi LUIS

Aplikacja LUIS zawiera model przetwarzania języka naturalnego (NLP), w tym intencje, jednostki i przykładowe wypowiedzi.

Utwórz metodę dodawania obiektu AppsOperation w celu utworzenia aplikacji. Wymagane są właściwości nazwy i kultury językowej.

const create_app_payload = {
    name: appName,
    initialVersionId: versionId,
    culture: "en-us"
};

const createAppResult = await client.apps.add(
    create_app_payload
);

const appId = createAppResult.body

Tworzenie intencji dla aplikacji

Podstawowym obiektem w modelu aplikacji usługi LUIS jest intencja. Intencja jest zgodna z grupowaniem intencji wypowiedzi użytkownika. Użytkownik może zadać pytanie lub utworzyć instrukcję wyszukując określoną odpowiedź z bota (lub innej aplikacji klienckiej). Przykłady intencji to rezerwacja lotu, proszenie o pogodę w docelowym mieście i proszenie o informacje kontaktowe dla obsługi klienta.

Użyj metody model.add_intent z nazwą unikatowej intencji, a następnie przekaż identyfikator aplikacji, identyfikator wersji i nową nazwę intencji.

Wartość intentName jest trwale zakodowana jako OrderPizzaIntent część zmiennych w sekcji Tworzenie zmiennych dla aplikacji .

await client.model.addIntent(
    appId,
    versionId,
    { name: intentName }
);

Tworzenie jednostek dla aplikacji

Chociaż jednostki nie są wymagane, znajdują się w większości aplikacji. Jednostka wyodrębnia informacje z wypowiedzi użytkownika, niezbędne do pełnego filtrowania intencji użytkownika. Istnieje kilka typów wstępnie utworzonych i niestandardowych jednostek, z których każdy ma własne modele obiektu przekształcania danych (DTO). Typowe wstępnie utworzone jednostki do dodania do aplikacji obejmują liczbę, datę/godzinaV2, geografięV2 lub porządkową.

Ważne jest, aby wiedzieć, że jednostki nie są oznaczone intencją. Mogą one i zwykle mają zastosowanie do wielu intencji. Tylko przykładowe wypowiedzi użytkowników są oznaczane dla określonej, pojedynczej intencji.

Metody tworzenia jednostek są częścią klasy Model . Każdy typ jednostki ma własny model obiektu przekształcania danych (DTO).

Kod tworzenia jednostki tworzy jednostkę uczenia maszynowego z jednostkami podrzędnymi i funkcjami zastosowanymi do Quantity podentiencji.

// Add Prebuilt entity
await client.model.addPrebuilt(appId, versionId, ["number"]);

// Define ml entity with children and grandchildren
const mlEntityDefinition = {
    name: "Pizza order",
    children: [
        {
            name: "Pizza",
            children: [
                { name: "Quantity" },
                { name: "Type" },
                { name: "Size" }
            ]
        },
        {
            name: "Toppings",
            children: [
                { name: "Type" },
                { name: "Quantity" }
            ]
        }
    ]
};

// Add ML entity 
const response = await client.model.addEntity(appId, versionId, mlEntityDefinition);
const mlEntityId = response.body;

// Add phraselist feature
const phraselistResponse = await client.features.addPhraseList(appId, versionId, {
    enabledForAllModels: false,
    isExchangeable: true,
    name: "QuantityPhraselist",
    phrases: "few,more,extra"
});
const phraseListId = phraselistResponse.body;

// Get entity and subentities
const model = await client.model.getEntity(appId, versionId, mlEntityId);
const toppingQuantityId = getModelGrandchild(model, "Toppings", "Quantity");
const pizzaQuantityId = getModelGrandchild(model, "Pizza", "Quantity");

// add model as feature to subentity model
await client.features.addEntityFeature(appId, versionId, pizzaQuantityId, { modelName: "number", isRequired: true });
await client.features.addEntityFeature(appId, versionId, toppingQuantityId, { modelName: "number" });

// add phrase list as feature to subentity model
await client.features.addEntityFeature(appId, versionId, toppingQuantityId, { featureName: "QuantityPhraselist" });

Umieść następującą quickstart metodę powyżej metody , aby znaleźć identyfikator podentulności Quantity, aby przypisać funkcje do tej podentyjności.

const getModelGrandchild = (model, childName, grandchildName) => {

    return model.children.find(c => c.name == childName).children.find(c => c.name == grandchildName).id

}

Dodawanie przykładowej wypowiedzi do intencji

Aby określić intencję wypowiedzi i wyodrębnić jednostki, aplikacja potrzebuje przykładów wypowiedzi. Przykłady muszą być przeznaczone dla określonej, pojedynczej intencji i powinny oznaczać wszystkie jednostki niestandardowe. Wstępnie utworzone jednostki nie muszą być oznaczone.

Dodaj przykładowe wypowiedzi, tworząc listę obiektów ExampleLabelObject, jeden obiekt dla każdej przykładowej wypowiedzi. Każdy przykład powinien oznaczać wszystkie jednostki ze słownikiem par nazwa/wartość jednostki i wartości jednostki. Wartość jednostki powinna być dokładnie tak, jak jest wyświetlana w tekście przykładowej wypowiedzi.

Wywołaj metodę examples.add przy użyciu identyfikatora aplikacji, identyfikatora wersji i przykładu.

// Define labeled example
const labeledExampleUtteranceWithMLEntity =
{
    text: "I want two small seafood pizzas with extra cheese.",
    intentName: intentName,
    entityLabels: [
        {
            startCharIndex: 7,
            endCharIndex: 48,
            entityName: "Pizza order",
            children: [
                {
                    startCharIndex: 7,
                    endCharIndex: 30,
                    entityName: "Pizza",
                    children: [
                        {
                            startCharIndex: 7,
                            endCharIndex: 9,
                            entityName: "Quantity"
                        },
                        {
                            startCharIndex: 11,
                            endCharIndex: 15,
                            entityName: "Size"
                        },
                        {
                            startCharIndex: 17,
                            endCharIndex: 23,
                            entityName: "Type"
                        }]
                },
                {
                    startCharIndex: 37,
                    endCharIndex: 48,
                    entityName: "Toppings",
                    children: [
                        {
                            startCharIndex: 37,
                            endCharIndex: 41,
                            entityName: "Quantity"
                        },
                        {
                            startCharIndex: 43,
                            endCharIndex: 48,
                            entityName: "Type"
                        }]
                }
            ]
        }
    ]
};

console.log("Labeled Example Utterance:", JSON.stringify(labeledExampleUtteranceWithMLEntity, null, 4 ));

// Add an example for the entity.
// Enable nested children to allow using multiple models with the same name.
// The quantity subentity and the phraselist could have the same exact name if this is set to True
await client.examples.add(appId, versionId, labeledExampleUtteranceWithMLEntity, { enableNestedChildren: true });

Uczenie aplikacji

Po utworzeniu modelu należy wytrenować aplikację usługi LUIS dla tej wersji modelu. Wytrenowany model może być używany w kontenerze lub publikowany w miejscach przejściowych lub produktowych.

Metoda train.trainVersion wymaga identyfikatora aplikacji i identyfikatora wersji.

Bardzo mały model, taki jak pokazano w tym przewodniku Szybki start, będzie trenował bardzo szybko. W przypadku aplikacji na poziomie produkcyjnym trenowanie aplikacji powinno zawierać wywołanie sondowania do metody get_status w celu określenia, kiedy lub kiedy trenowanie zakończyło się pomyślnie. Odpowiedź to lista obiektów ModelTrainingInfo z oddzielnym stanem dla każdego obiektu. Wszystkie obiekty muszą zakończyć się pomyślnie, aby trenowanie zostało uznane za ukończone.

await client.train.trainVersion(appId, versionId);
while (true) {
    const status = await client.train.getStatus(appId, versionId);
    if (status.every(m => m.details.status == "Success")) {
        // Assumes that we never fail, and that eventually we'll always succeed.
        break;
    }
}

Publikowanie aplikacji w miejscu produkcyjnym

Opublikuj aplikację usługi LUIS przy użyciu metody app.publish . Spowoduje to opublikowanie bieżącej wytrenowanego wersji do określonego miejsca w punkcie końcowym. Aplikacja kliencka używa tego punktu końcowego do wysyłania wypowiedzi użytkownika na potrzeby przewidywania intencji i wyodrębniania jednostek.

await client.apps.publish(appId, { versionId: versionId, isStaging: false });

Uwierzytelnianie klienta środowiska uruchomieniowego przewidywania

Użyj obiektu msRest.ApiKeyCredentials z kluczem i użyj go z punktem końcowym, aby utworzyć usługę LUIS. LUISRuntimeClient , obiekt.

Uwaga

Ten przewodnik Szybki start używa klucza tworzenia w ramach poświadczeń środowiska uruchomieniowego. Klucz tworzenia może wykonywać zapytania względem środowiska uruchomieniowego za pomocą kilku zapytań. W przypadku kodu przejściowego i produkcyjnego zastąp klucz tworzenia kluczem środowiska uruchomieniowego przewidywania.

const luisPredictionClient = new LUIS_Prediction.LUISRuntimeClient(
    luisAuthoringCredentials,
    predictionEndpoint
);

Pobieranie przewidywania ze środowiska uruchomieniowego

Dodaj następujący kod, aby utworzyć żądanie do środowiska uruchomieniowego przewidywania. Wypowiedź użytkownika jest częścią obiektu predictionRequest.

Metoda luisRuntimeClient.prediction.getSlotPrediction wymaga kilku parametrów, takich jak identyfikator aplikacji, nazwa miejsca i obiekt żądania przewidywania w celu spełnienia żądania. Inne opcje, takie jak pełne, pokaż wszystkie intencje i dziennik, są opcjonalne.

// Production == slot name
const request = { query: "I want two small pepperoni pizzas with more salsa" };
const response = await luisPredictionClient.prediction.getSlotPrediction(appId, "Production", request);
console.log(JSON.stringify(response.prediction, null, 4 ));

Odpowiedź przewidywania to obiekt JSON, w tym intencja i wszystkie znalezione jednostki.

{
    "query": "I want two small pepperoni pizzas with more salsa",
    "prediction": {
        "topIntent": "OrderPizzaIntent",
        "intents": {
            "OrderPizzaIntent": {
                "score": 0.753606856
            },
            "None": {
                "score": 0.119097039
            }
        },
        "entities": {
            "Pizza order": [
                {
                    "Pizza": [
                        {
                            "Quantity": [
                                2
                            ],
                            "Type": [
                                "pepperoni"
                            ],
                            "Size": [
                                "small"
                            ],
                            "$instance": {
                                "Quantity": [
                                    {
                                        "type": "builtin.number",
                                        "text": "two",
                                        "startIndex": 7,
                                        "length": 3,
                                        "score": 0.968156934,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ],
                                "Type": [
                                    {
                                        "type": "Type",
                                        "text": "pepperoni",
                                        "startIndex": 17,
                                        "length": 9,
                                        "score": 0.9345611,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ],
                                "Size": [
                                    {
                                        "type": "Size",
                                        "text": "small",
                                        "startIndex": 11,
                                        "length": 5,
                                        "score": 0.9592077,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ]
                            }
                        }
                    ],
                    "Toppings": [
                        {
                            "Type": [
                                "salsa"
                            ],
                            "Quantity": [
                                "more"
                            ],
                            "$instance": {
                                "Type": [
                                    {
                                        "type": "Type",
                                        "text": "salsa",
                                        "startIndex": 44,
                                        "length": 5,
                                        "score": 0.7292897,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ],
                                "Quantity": [
                                    {
                                        "type": "Quantity",
                                        "text": "more",
                                        "startIndex": 39,
                                        "length": 4,
                                        "score": 0.9320932,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ]
                            }
                        }
                    ],
                    "$instance": {
                        "Pizza": [
                            {
                                "type": "Pizza",
                                "text": "two small pepperoni pizzas",
                                "startIndex": 7,
                                "length": 26,
                                "score": 0.812199831,
                                "modelTypeId": 1,
                                "modelType": "Entity Extractor",
                                "recognitionSources": [
                                    "model"
                                ]
                            }
                        ],
                        "Toppings": [
                            {
                                "type": "Toppings",
                                "text": "more salsa",
                                "startIndex": 39,
                                "length": 10,
                                "score": 0.7250252,
                                "modelTypeId": 1,
                                "modelType": "Entity Extractor",
                                "recognitionSources": [
                                    "model"
                                ]
                            }
                        ]
                    }
                }
            ],
            "$instance": {
                "Pizza order": [
                    {
                        "type": "Pizza order",
                        "text": "two small pepperoni pizzas with more salsa",
                        "startIndex": 7,
                        "length": 42,
                        "score": 0.769223332,
                        "modelTypeId": 1,
                        "modelType": "Entity Extractor",
                        "recognitionSources": [
                            "model"
                        ]
                    }
                ]
            }
        }
    }
}

Uruchamianie aplikacji

Uruchom aplikację, wykonując polecenie node index.js dla pliku szybkiego startu.

node index.js

Użyj bibliotek klienckich usługi Language Understanding (LUIS) dla języka Python, aby:

• Utwórz aplikację
• Dodawanie intencji, jednostki wyuczonej maszynowo z przykładową wypowiedzią
• Trenowanie i publikowanie aplikacji
• Środowisko uruchomieniowe przewidywania zapytania

Dokumentacja referencyjna | : Tworzenie i kod źródłowy biblioteki przewidywania | Package (Pypi) | Samples

Wymagania wstępne

• Bieżąca wersja języka Python 3.x.
• Subskrypcja platformy Azure — utwórz bezpłatnie
• Po utworzeniu subskrypcji platformy Azure utwórz zasób tworzenia usługi Language Understanding w witrynie Azure Portal, aby uzyskać klucz i punkt końcowy. Poczekaj na wdrożenie i kliknij przycisk Przejdź do zasobu .
  • Będziesz potrzebować klucza i punktu końcowego z utworzonego zasobu, aby połączyć aplikację z tworzeniem usługi Language Understanding. W dalszej części przewodnika Szybki start wklejesz klucz i punkt końcowy do poniższego kodu. Aby wypróbować usługę, możesz użyć bezpłatnej warstwy cenowej (F0).

Konfigurowanie

Tworzenie nowej aplikacji w języku Python

1. W oknie konsoli utwórz nowy katalog dla aplikacji i przejdź do tego katalogu.

   mkdir quickstart-sdk && cd quickstart-sdk
   

2. Utwórz plik o nazwie authoring_and_predict.py dla kodu w języku Python.

   touch authoring_and_predict.py
   

Instalowanie biblioteki klienta za pomocą narzędzia Pip

W katalogu aplikacji zainstaluj bibliotekę klienta usługi Language Understanding (LUIS) dla języka Python za pomocą następującego polecenia:

pip install azure-cognitiveservices-language-luis

Tworzenie modelu obiektów

Klient tworzenia usługi Language Understanding (LUIS) to obiekt LUISAuthoringClient , który uwierzytelnia się na platformie Azure, który zawiera klucz tworzenia.

Przykłady kodu do tworzenia

Po utworzeniu klienta użyj tego klienta, aby uzyskać dostęp do funkcji, w tym:

• Aplikacje — tworzenie, usuwanie, publikowanie
• Przykładowe wypowiedzi — dodawanie według partii, usuwanie według identyfikatora
• Funkcje — zarządzanie listami fraz
• Model — zarządzanie intencjami i jednostkami
• Wzorzec — zarządzanie wzorcami
• Trenowanie — szkolenie aplikacji i sondowania pod kątem stanu trenowania
• Wersje — zarządzanie za pomocą klonowania, eksportowania i usuwania

Model obiektu przewidywania

Klient środowiska uruchomieniowego przewidywania usługi Language Understanding (LUIS) to obiekt LUISRuntimeClient , który uwierzytelnia się na platformie Azure, który zawiera klucz zasobu.

Przykłady kodu dla środowiska uruchomieniowego przewidywania

Po utworzeniu klienta użyj tego klienta, aby uzyskać dostęp do funkcji, w tym:

• Przewidywanie według miejsca przejściowego lub produkcyjnego
• Przewidywanie według wersji

Przykłady kodu

Te fragmenty kodu pokazują, jak wykonać następujące czynności za pomocą biblioteki klienta usługi Language Understanding (LUIS) dla języka Python:

• Tworzenie aplikacji
• Dodawanie intencji
• Dodawanie jednostek
• Dodawanie przykładowych wypowiedzi
• Trenowanie aplikacji
• Publikowanie aplikacji
• Przewidywanie według miejsca

Dodawanie zależności

Dodaj biblioteki klienckie do pliku języka Python.

from azure.cognitiveservices.language.luis.authoring import LUISAuthoringClient
from azure.cognitiveservices.language.luis.authoring.models import ApplicationCreateObject
from azure.cognitiveservices.language.luis.runtime import LUISRuntimeClient
from msrest.authentication import CognitiveServicesCredentials
from functools import reduce

import json, time, uuid

Dodawanie kodu kociołowego

1. Dodaj metodę quickstart i jej wywołanie. Ta metoda przechowuje większość pozostałego kodu. Ta metoda jest wywoływana na końcu pliku.

   def quickstart():
   
       # add calls here, remember to indent properly
   
   quickstart()
   

2. Dodaj pozostały kod w metodzie Szybkiego startu, chyba że określono inaczej.

Tworzenie zmiennych dla aplikacji

Utwórz dwa zestawy zmiennych: pierwszy zestaw, który zostanie zmieniony, drugi zestaw pozostawi się tak, jak są wyświetlane w przykładzie kodu.

Ważne

Pamiętaj, aby usunąć klucz z kodu po zakończeniu i nigdy nie publikować go publicznie. W przypadku środowiska produkcyjnego użyj bezpiecznego sposobu przechowywania i uzyskiwania dostępu do poświadczeń, takich jak usługa Azure Key Vault. Aby uzyskać więcej informacji, zobacz artykuł Dotyczący zabezpieczeń usług Azure AI.

1. Utwórz zmienne do przechowywania klucza tworzenia i nazw zasobów.

   authoringKey = 'PASTE_YOUR_LUIS_AUTHORING_SUBSCRIPTION_KEY_HERE'
   authoringEndpoint = 'PASTE_YOUR_LUIS_AUTHORING_ENDPOINT_HERE'
   predictionKey = 'PASTE_YOUR_LUIS_PREDICTION_SUBSCRIPTION_KEY_HERE'
   predictionEndpoint = 'PASTE_YOUR_LUIS_PREDICTION_ENDPOINT_HERE'
   

2. Utwórz zmienne do przechowywania punktów końcowych, nazwy aplikacji, wersji i nazwy intencji.

   # We use a UUID to avoid name collisions.
   appName = "Contoso Pizza Company " + str(uuid.uuid4())
   versionId = "0.1"
   intentName = "OrderPizzaIntent"
   

Uwierzytelnianie użytkownika

Utwórz obiekt CognitiveServicesCredentials przy użyciu klucza i użyj go z punktem końcowym, aby utworzyć obiekt LUISAuthoringClient .

client = LUISAuthoringClient(authoringEndpoint, CognitiveServicesCredentials(authoringKey))

Tworzenie aplikacji usługi LUIS

Aplikacja LUIS zawiera model przetwarzania języka naturalnego (NLP), w tym intencje, jednostki i przykładowe wypowiedzi.

Utwórz metodę dodawania obiektu AppsOperation w celu utworzenia aplikacji. Wymagane są właściwości nazwy i kultury językowej.

# define app basics
appDefinition = ApplicationCreateObject (name=appName, initial_version_id=versionId, culture='en-us')

# create app
app_id = client.apps.add(appDefinition)

# get app id - necessary for all other changes
print("Created LUIS app with ID {}".format(app_id))

Tworzenie intencji dla aplikacji

Podstawowym obiektem w modelu aplikacji usługi LUIS jest intencja. Intencja jest zgodna z grupowaniem intencji wypowiedzi użytkownika. Użytkownik może zadać pytanie lub utworzyć instrukcję wyszukując określoną odpowiedź z bota (lub innej aplikacji klienckiej). Przykłady intencji to rezerwacja lotu, proszenie o pogodę w docelowym mieście i proszenie o informacje kontaktowe dla obsługi klienta.

Użyj metody model.add_intent z nazwą unikatowej intencji, a następnie przekaż identyfikator aplikacji, identyfikator wersji i nową nazwę intencji.

Wartość intentName jest trwale zakodowana jako OrderPizzaIntent część zmiennych w sekcji Tworzenie zmiennych dla aplikacji .

client.model.add_intent(app_id, versionId, intentName)

Tworzenie jednostek dla aplikacji

Chociaż jednostki nie są wymagane, znajdują się w większości aplikacji. Jednostka wyodrębnia informacje z wypowiedzi użytkownika, niezbędne do pełnego filtrowania intencji użytkownika. Istnieje kilka typów wstępnie utworzonych i niestandardowych jednostek, z których każdy ma własne modele obiektu przekształcania danych (DTO). Typowe wstępnie utworzone jednostki do dodania do aplikacji obejmują liczbę, datę/godzinaV2, geografięV2 lub porządkową.

Ważne jest, aby wiedzieć, że jednostki nie są oznaczone intencją. Mogą one i zwykle mają zastosowanie do wielu intencji. Tylko przykładowe wypowiedzi użytkowników są oznaczane dla określonej, pojedynczej intencji.

Metody tworzenia jednostek są częścią klasy ModelOperations . Każdy typ jednostki ma własny model obiektu przekształcania danych (DTO).

Kod tworzenia jednostki tworzy jednostkę uczenia maszynowego z jednostkami podrzędnymi i funkcjami zastosowanymi do Quantity podentiencji.

# Add Prebuilt entity
client.model.add_prebuilt(app_id, versionId, prebuilt_extractor_names=["number"])

# define machine-learned entity
mlEntityDefinition = [
{
    "name": "Pizza",
    "children": [
        { "name": "Quantity" },
        { "name": "Type" },
        { "name": "Size" }
    ]
},
{
    "name": "Toppings",
    "children": [
        { "name": "Type" },
        { "name": "Quantity" }
    ]
}]

# add entity to app
modelId = client.model.add_entity(app_id, versionId, name="Pizza order", children=mlEntityDefinition)

# define phraselist - add phrases as significant vocabulary to app
phraseList = {
    "enabledForAllModels": False,
    "isExchangeable": True,
    "name": "QuantityPhraselist",
    "phrases": "few,more,extra"
}

# add phrase list to app
phraseListId = client.features.add_phrase_list(app_id, versionId, phraseList)

# Get entity and subentities
modelObject = client.model.get_entity(app_id, versionId, modelId)
toppingQuantityId = get_grandchild_id(modelObject, "Toppings", "Quantity")
pizzaQuantityId = get_grandchild_id(modelObject, "Pizza", "Quantity")

# add model as feature to subentity model
prebuiltFeatureRequiredDefinition = { "model_name": "number", "is_required": True }
client.features.add_entity_feature(app_id, versionId, pizzaQuantityId, prebuiltFeatureRequiredDefinition)

# add model as feature to subentity model
prebuiltFeatureNotRequiredDefinition = { "model_name": "number" }
client.features.add_entity_feature(app_id, versionId, toppingQuantityId, prebuiltFeatureNotRequiredDefinition)

# add phrase list as feature to subentity model
phraseListFeatureDefinition = { "feature_name": "QuantityPhraselist", "model_name": None }
client.features.add_entity_feature(app_id, versionId, toppingQuantityId, phraseListFeatureDefinition)

Umieść następującą quickstart metodę powyżej metody , aby znaleźć identyfikator podentulności Quantity, aby przypisać funkcje do tej podentyjności.

def get_grandchild_id(model, childName, grandChildName):
    
    theseChildren = next(filter((lambda child: child.name == childName), model.children))
    theseGrandchildren = next(filter((lambda child: child.name == grandChildName), theseChildren.children))
    
    grandChildId = theseGrandchildren.id
    
    return grandChildId

Dodawanie przykładowej wypowiedzi do intencji

Aby określić intencję wypowiedzi i wyodrębnić jednostki, aplikacja potrzebuje przykładów wypowiedzi. Przykłady muszą być przeznaczone dla określonej, pojedynczej intencji i powinny oznaczać wszystkie jednostki niestandardowe. Wstępnie utworzone jednostki nie muszą być oznaczone.

Dodaj przykładowe wypowiedzi, tworząc listę obiektów ExampleLabelObject , jeden obiekt dla każdej przykładowej wypowiedzi. Każdy przykład powinien oznaczać wszystkie jednostki ze słownikiem par nazwa/wartość jednostki i wartości jednostki. Wartość jednostki powinna być dokładnie tak, jak jest wyświetlana w tekście przykładowej wypowiedzi.

Wywołaj metodę examples.add przy użyciu identyfikatora aplikacji, identyfikatora wersji i przykładu.

# Define labeled example
labeledExampleUtteranceWithMLEntity = {
    "text": "I want two small seafood pizzas with extra cheese.",
    "intentName": intentName,
    "entityLabels": [
        {
            "startCharIndex": 7,
            "endCharIndex": 48,
            "entityName": "Pizza order",
            "children": [
                {
                    "startCharIndex": 7,
                    "endCharIndex": 30,
                    "entityName": "Pizza",
                    "children": [
                        {
                            "startCharIndex": 7,
                            "endCharIndex": 9,
                            "entityName": "Quantity"
                        },
                        {
                            "startCharIndex": 11,
                            "endCharIndex": 15,
                            "entityName": "Size"
                        },
                        {
                            "startCharIndex": 17,
                            "endCharIndex": 23,
                            "entityName": "Type"
                        }]
                },
                {
                    "startCharIndex": 37,
                    "endCharIndex": 48,
                    "entityName": "Toppings",
                    "children": [
                        {
                            "startCharIndex": 37,
                            "endCharIndex": 41,
                            "entityName": "Quantity"
                        },
                        {
                            "startCharIndex": 43,
                            "endCharIndex": 48,
                            "entityName": "Type"
                        }]
                }
            ]
        }
    ]
}

print("Labeled Example Utterance:", labeledExampleUtteranceWithMLEntity)

# Add an example for the entity.
# Enable nested children to allow using multiple models with the same name.
# The quantity subentity and the phraselist could have the same exact name if this is set to True
client.examples.add(app_id, versionId, labeledExampleUtteranceWithMLEntity, { "enableNestedChildren": True })

Uczenie aplikacji

Po utworzeniu modelu należy wytrenować aplikację usługi LUIS dla tej wersji modelu. Wytrenowany model może być używany w kontenerze lub publikowany w miejscach przejściowych lub produktowych.

Metoda train.train_version wymaga identyfikatora aplikacji i identyfikatora wersji.

Bardzo mały model, taki jak pokazano w tym przewodniku Szybki start, będzie trenował bardzo szybko. W przypadku aplikacji na poziomie produkcyjnym trenowanie aplikacji powinno zawierać wywołanie sondowania do metody get_status w celu określenia, kiedy lub kiedy trenowanie zakończyło się pomyślnie. Odpowiedź to lista obiektów ModelTrainingInfo z oddzielnym stanem dla każdego obiektu. Wszystkie obiekty muszą zakończyć się pomyślnie, aby trenowanie zostało uznane za ukończone.

client.train.train_version(app_id, versionId)
waiting = True
while waiting:
    info = client.train.get_status(app_id, versionId)

    # get_status returns a list of training statuses, one for each model. Loop through them and make sure all are done.
    waiting = any(map(lambda x: 'Queued' == x.details.status or 'InProgress' == x.details.status, info))
    if waiting:
        print ("Waiting 10 seconds for training to complete...")
        time.sleep(10)
    else: 
        print ("trained")
        waiting = False

Publikowanie aplikacji w miejscu produkcyjnym

Opublikuj aplikację usługi LUIS przy użyciu metody app.publish . Spowoduje to opublikowanie bieżącej wytrenowanego wersji do określonego miejsca w punkcie końcowym. Aplikacja kliencka używa tego punktu końcowego do wysyłania wypowiedzi użytkownika na potrzeby przewidywania intencji i wyodrębniania jednostek.

# Mark the app as public so we can query it using any prediction endpoint.
# Note: For production scenarios, you should instead assign the app to your own LUIS prediction endpoint. See:
# https://docs.microsoft.com/en-gb/azure/cognitive-services/luis/luis-how-to-azure-subscription#assign-a-resource-to-an-app
client.apps.update_settings(app_id, is_public=True)

responseEndpointInfo = client.apps.publish(app_id, versionId, is_staging=False)

Uwierzytelnianie klienta środowiska uruchomieniowego przewidywania

Użyj obiektu credentials z kluczem i użyj go z punktem końcowym, aby utworzyć obiekt LUISRuntimeClientConfiguration .

Uwaga

Ten przewodnik Szybki start używa klucza tworzenia w ramach poświadczeń środowiska uruchomieniowego. Klucz tworzenia może wykonywać zapytania względem środowiska uruchomieniowego za pomocą kilku zapytań. W przypadku kodu przejściowego i produkcyjnego zastąp klucz tworzenia kluczem środowiska uruchomieniowego przewidywania.

runtimeCredentials = CognitiveServicesCredentials(predictionKey)
clientRuntime = LUISRuntimeClient(endpoint=predictionEndpoint, credentials=runtimeCredentials)

Pobieranie przewidywania ze środowiska uruchomieniowego

Dodaj następujący kod, aby utworzyć żądanie do środowiska uruchomieniowego przewidywania.

Wypowiedź użytkownika jest częścią obiektu prediction_request .

Metoda get_slot_prediction wymaga kilku parametrów, takich jak identyfikator aplikacji, nazwa miejsca i obiekt żądania przewidywania w celu spełnienia żądania. Inne opcje, takie jak pełne, pokaż wszystkie intencje i dziennik, są opcjonalne. Żądanie zwraca obiekt PredictionResponse .

# Production == slot name
predictionRequest = { "query" : "I want two small pepperoni pizzas with more salsa" }

predictionResponse = clientRuntime.prediction.get_slot_prediction(app_id, "Production", predictionRequest)
print("Top intent: {}".format(predictionResponse.prediction.top_intent))
print("Sentiment: {}".format (predictionResponse.prediction.sentiment))
print("Intents: ")

for intent in predictionResponse.prediction.intents:
    print("\t{}".format (json.dumps (intent)))
print("Entities: {}".format (predictionResponse.prediction.entities))

Odpowiedź przewidywania to obiekt JSON, w tym intencja i wszystkie znalezione jednostki.

{
    "query": "I want two small pepperoni pizzas with more salsa",
    "prediction": {
        "topIntent": "OrderPizzaIntent",
        "intents": {
            "OrderPizzaIntent": {
                "score": 0.753606856
            },
            "None": {
                "score": 0.119097039
            }
        },
        "entities": {
            "Pizza order": [
                {
                    "Pizza": [
                        {
                            "Quantity": [
                                2
                            ],
                            "Type": [
                                "pepperoni"
                            ],
                            "Size": [
                                "small"
                            ],
                            "$instance": {
                                "Quantity": [
                                    {
                                        "type": "builtin.number",
                                        "text": "two",
                                        "startIndex": 7,
                                        "length": 3,
                                        "score": 0.968156934,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ],
                                "Type": [
                                    {
                                        "type": "Type",
                                        "text": "pepperoni",
                                        "startIndex": 17,
                                        "length": 9,
                                        "score": 0.9345611,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ],
                                "Size": [
                                    {
                                        "type": "Size",
                                        "text": "small",
                                        "startIndex": 11,
                                        "length": 5,
                                        "score": 0.9592077,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ]
                            }
                        }
                    ],
                    "Toppings": [
                        {
                            "Type": [
                                "salsa"
                            ],
                            "Quantity": [
                                "more"
                            ],
                            "$instance": {
                                "Type": [
                                    {
                                        "type": "Type",
                                        "text": "salsa",
                                        "startIndex": 44,
                                        "length": 5,
                                        "score": 0.7292897,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ],
                                "Quantity": [
                                    {
                                        "type": "Quantity",
                                        "text": "more",
                                        "startIndex": 39,
                                        "length": 4,
                                        "score": 0.9320932,
                                        "modelTypeId": 1,
                                        "modelType": "Entity Extractor",
                                        "recognitionSources": [
                                            "model"
                                        ]
                                    }
                                ]
                            }
                        }
                    ],
                    "$instance": {
                        "Pizza": [
                            {
                                "type": "Pizza",
                                "text": "two small pepperoni pizzas",
                                "startIndex": 7,
                                "length": 26,
                                "score": 0.812199831,
                                "modelTypeId": 1,
                                "modelType": "Entity Extractor",
                                "recognitionSources": [
                                    "model"
                                ]
                            }
                        ],
                        "Toppings": [
                            {
                                "type": "Toppings",
                                "text": "more salsa",
                                "startIndex": 39,
                                "length": 10,
                                "score": 0.7250252,
                                "modelTypeId": 1,
                                "modelType": "Entity Extractor",
                                "recognitionSources": [
                                    "model"
                                ]
                            }
                        ]
                    }
                }
            ],
            "$instance": {
                "Pizza order": [
                    {
                        "type": "Pizza order",
                        "text": "two small pepperoni pizzas with more salsa",
                        "startIndex": 7,
                        "length": 42,
                        "score": 0.769223332,
                        "modelTypeId": 1,
                        "modelType": "Entity Extractor",
                        "recognitionSources": [
                            "model"
                        ]
                    }
                ]
            }
        }
    }
}

Uruchamianie aplikacji

Uruchom aplikację, wykonując polecenie python dla pliku szybkiego startu.

python authoring_and_predict.py

Korzystając z tego przewodnika Szybki start, wykonasz trzy wywołania REST w sekwencji.

• Najpierw przekażesz partię przykładowych wypowiedzi, które będą używane do trenowania modelu aplikacji Pizza przy użyciu wywołania dodawania etykiet w usłudze REST Batch.
• Następnie rozpoczniesz sesję szkoleniową dla aplikacji Pizza przy użyciu wywołania wersji aplikacji REST Train.
• Na koniec uzyskasz stan sesji szkoleniowej dla aplikacji Pizza przy użyciu wywołania stanu trenowania wersji REST Pobierz wersję.

Dokumentacja referencyjna

Wymagania wstępne

• Bezpłatne konto usługi LUIS .

• Edytor tekstów, taki jak Visual Studio Code.

• Program wiersza polecenia cURL. Program cURL jest już zainstalowany w systemie macOS, większości dystrybucji systemu Linux i kompilacji systemu Windows 10 w wersji 1803 lub nowszej.

  Jeśli musisz zainstalować program cURL, możesz pobrać plik cURL ze strony pobierania programu cURL.

Tworzenie aplikacji pizza

Utwórz aplikację pizzy.

1. Wybierz pizza-app-for-luis-v6.json , aby wyświetlić stronę usługi GitHub dla pizza-app-for-luis.json pliku.
2. Kliknij prawym przyciskiem myszy lub naciśnij przycisk Raw (Nieprzetworzone ) i wybierz polecenie Save link ( Zapisz link), aby zapisać pizza-app-for-luis.json go na komputerze.
3. Zaloguj się do portalu usługi LUIS.
4. Wybierz pozycję Moje aplikacje.
5. Na stronie Moje aplikacje wybierz pozycję + Nowa aplikacja do konwersacji.
6. Wybierz pozycję Importuj jako plik JSON.
7. W oknie dialogowym Importowanie nowej aplikacji wybierz przycisk Wybierz plik .
8. pizza-app-for-luis.json Wybierz pobrany plik, a następnie wybierz pozycję Otwórz.
9. W oknie dialogowym Importowanie nowej aplikacji Nazwa wprowadź nazwę aplikacji Pizza, a następnie wybierz przycisk Gotowe.

Aplikacja zostanie zaimportowana.

Jeśli zostanie wyświetlone okno dialogowe Jak utworzyć efektywną aplikację usługi LUIS, zamknij okno dialogowe.

Trenowanie i publikowanie aplikacji Pizza

Powinna zostać wyświetlona strona Intents (Intencje ) z listą intencji w aplikacji Pizza.

1. W prawym górnym rogu witryny internetowej usługi LUIS wybierz przycisk Trenuj .

   

2. Trenowanie jest ukończone po wyłączeniu przycisku Train (Trenowanie).

Aby otrzymać przewidywanie usługi LUIS w czatbotze lub innych aplikacjach klienckich, należy opublikować aplikację w punkcie końcowym przewidywania.

1. Wybierz pozycję Publikuj w prawym górnym rogu nawigacji.

   

2. Wybierz miejsce produkcyjne, a następnie wybierz pozycję Gotowe.

   

3. Wybierz pozycję Uzyskaj dostęp do adresów URL punktów końcowych w powiadomieniu, aby przejść do strony Zasoby platformy Azure. Adresy URL będą widoczne tylko wtedy, gdy masz zasób przewidywania skojarzony z aplikacją. Możesz również znaleźć stronę Zasoby platformy Azure, klikając pozycję Zarządzaj.

   

Dodawanie zasobu tworzenia do aplikacji Pizza

1. Wybierz pozycję ZARZĄDZAJ.
2. Wybierz pozycję Azure Resources (Zasoby platformy Azure).
3. Wybierz pozycję Zasób tworzenia.
4. Wybierz pozycję Zmień zasób tworzenia.

Jeśli masz zasób tworzenia, wprowadź nazwę dzierżawy, nazwę subskrypcji i nazwę zasobu usługi LUIS zasobu tworzenia.

Jeśli nie masz zasobu tworzenia:

1. Wybierz pozycję Utwórz nowy zasób.
2. Wprowadź nazwę dzierżawy, nazwę zasobu, nazwę subskrypcji i nazwę grupy zasobów platformy Azure.

Aplikacja Pizza jest teraz gotowa do użycia.

Rejestrowanie wartości dostępu dla aplikacji Pizza

Aby korzystać z nowej aplikacji Pizza, musisz mieć identyfikator aplikacji, klucz tworzenia i punkt końcowy tworzenia aplikacji Pizza. Aby uzyskać przewidywania, potrzebujesz oddzielnego punktu końcowego przewidywania i klucza przewidywania.

Aby znaleźć następujące wartości:

1. Na stronie Intents (Intencje) wybierz pozycję MANAGE (ZARZĄDZAJ).
2. Na stronie Ustawienia aplikacji zapisz identyfikator aplikacji.
3. Wybierz pozycję Azure Resources (Zasoby platformy Azure).
4. Wybierz pozycję Zasób tworzenia.
5. Na kartach Zasoby tworzenia i zasoby przewidywania zapisz klucz podstawowy. Ta wartość jest kluczem tworzenia.
6. Zarejestruj adres URL punktu końcowego. Ta wartość to punkt końcowy tworzenia.

Tworzenie pliku JSON w celu wytrenowania aplikacji Pizza

Aby utworzyć plik JSON z trzema przykładowymi wypowiedziami, zapisz następujące dane JSON w pliku o nazwie ExampleUtterances.JSON:

[
  {
    "text": "order a pizza",
    "intentName": "ModifyOrder",
    "entityLabels": [
      {
        "entityName": "Order",
        "startCharIndex": 6,
        "endCharIndex": 12
      }
    ]
  },
  {
    "text": "order a large pepperoni pizza",
    "intentName": "ModifyOrder",
    "entityLabels": [
      {
        "entityName": "Order",
        "startCharIndex": 6,
        "endCharIndex": 28
      },
      {
        "entityName": "FullPizzaWithModifiers",
        "startCharIndex": 6,
        "endCharIndex": 28
      },
      {
        "entityName": "PizzaType",
        "startCharIndex": 14,
        "endCharIndex": 28
      },
      {
        "entityName": "Size",
        "startCharIndex": 8,
        "endCharIndex": 12
      }
    ]
  },
  {
    "text": "I want two large pepperoni pizzas on thin crust",
    "intentName": "ModifyOrder",
    "entityLabels": [
      {
        "entityName": "Order",
        "startCharIndex": 7,
        "endCharIndex": 46
      },
      {
        "entityName": "FullPizzaWithModifiers",
        "startCharIndex": 7,
        "endCharIndex": 46
      },
      {
        "entityName": "PizzaType",
        "startCharIndex": 17,
        "endCharIndex": 32
      },
      {
        "entityName": "Size",
        "startCharIndex": 11,
        "endCharIndex": 15
      },
      {
        "entityName": "Quantity",
        "startCharIndex": 7,
        "endCharIndex": 9
      },
      {
        "entityName": "Crust",
        "startCharIndex": 37,
        "endCharIndex": 46
      }
    ]
  }
]`

Przykładowe wypowiedzi JSON są zgodne z określonym formatem.

Pole text zawiera tekst przykładowej wypowiedzi. Pole intentName musi odpowiadać nazwie istniejącej wypowiedzi w aplikacji LUIS. Pole entityLabels jest wymagane. Jeśli nie chcesz dodawać etykiet do żadnych jednostek, podaj pustą tablicę.

Jeśli tablica entityLabels nie jest pusta, elementy startCharIndex i endCharIndex muszą oznaczać jednostkę określoną w polu entityName. Jest to indeks zaczynający się od zera. Jeśli zaczynasz lub kończysz etykietę w miejscu w tekście, wywołanie interfejsu API w celu dodania wypowiedzi zakończy się niepowodzeniem.

Dodawanie przykładowych wypowiedzi

1. Aby przekazać partię przykładowych wypowiedzi, skopiuj to polecenie do edytora tekstów:

   Windows

   curl "***YOUR-AUTHORING-ENDPOINT***/luis/authoring/v3.0-preview/apps/***YOUR-APP-ID***/versions/***YOUR-APP-VERSION***/examples?verbose=true&show-all-intents=true" ^
         --request POST ^
         --header "Content-Type:application/json" ^
         --header "Ocp-Apim-Subscription-Key: ***YOUR-AUTHORING-KEY***" ^
         --data "@ExampleUtterances.JSON"
   

   macOS

   curl "***YOUR-AUTHORING-ENDPOINT***/luis/authoring/v3.0-preview/apps/***YOUR-APP-ID***/versions/***YOUR-APP-VERSION***/examples?verbose=true&show-all-intents=true" \
         --request POST \
         --header "Content-Type:application/json" \
         --header "Ocp-Apim-Subscription-Key: ***YOUR-AUTHORING-KEY***" \
         --data "@ExampleUtterances.JSON"
   

   Linux

   curl "***YOUR-AUTHORING-ENDPOINT***/luis/authoring/v3.0-preview/apps/***YOUR-APP-ID***/versions/***YOUR-APP-VERSION***/examples?verbose=true&show-all-intents=true" \
         --request POST \
         --header "Content-Type:application/json" \
         --header "Ocp-Apim-Subscription-Key: ***YOUR-AUTHORING-KEY***" \
         --data "@ExampleUtterances.JSON"
   

2. Zastąp ***YOUR- wartości zaczynające się od własnych wartości.

   Informacja	Purpose
   ***YOUR-AUTHORING-ENDPOINT***	Punkt końcowy adresu URL tworzenia. Na przykład "https://REPLACE-WITH-YOUR-RESOURCE-NAME.api.cognitive.microsoft.com/". Nazwa zasobu została ustawiona podczas tworzenia zasobu.
   ***YOUR-APP-ID***	Identyfikator aplikacji usługi LUIS.
   ***YOUR-APP-VERSION***	Wersja aplikacji usługi LUIS. W przypadku aplikacji Pizza numer wersji to "0.1" bez cudzysłowów.
   ***YOUR-AUTHORING-KEY***	Klucz tworzenia 32 znaków.

   Przypisane klucze i zasoby są widoczne w portalu usługi LUIS w sekcji Zarządzanie na stronie zasobów platformy Azure. Identyfikator aplikacji jest dostępny w tej samej sekcji Zarządzanie na stronie Ustawienia aplikacji.

   Ważne

   Pamiętaj, aby usunąć klucz z kodu po zakończeniu i nigdy nie publikować go publicznie. W przypadku środowiska produkcyjnego użyj bezpiecznego sposobu przechowywania i uzyskiwania dostępu do poświadczeń, takich jak usługa Azure Key Vault. Aby uzyskać więcej informacji, zobacz artykuł Dotyczący zabezpieczeń usług Azure AI.

3. Uruchom wiersz polecenia (Windows) lub terminal (macOS i Linux) i zmień katalogi na ten sam katalog, w którym zapisano ExampleUtterances.JSON plik.

4. Skopiuj polecenie cURL z edytora i wklej je w wierszu polecenia (Windows) lub terminalu (macOS i Linux). Naciśnij klawisz Enter, aby wykonać polecenie.

   Powinna zostać wyświetlona następująca odpowiedź:

   [{"value":{"ExampleId":1255129706,"UtteranceText":"order a pizza"},"hasError":false},{"value":{"ExampleId":1255129707,"UtteranceText":"order a large pepperoni pizza"},"hasError":false},{"value":{"ExampleId":1255129708,"UtteranceText":"i want two large pepperoni pizzas on thin crust"},"hasError":false}]
   

   Oto dane wyjściowe sformatowane pod kątem czytelności:

   [
     {
       "value": {
         "ExampleId": 1255129706,
         "UtteranceText": "order a pizza"
       },
       "hasError": false
     },
     {
       "value": {
         "ExampleId": 1255129707,
         "UtteranceText": "order a large pepperoni pizza"
       },
       "hasError": false
     },
     {
       "value": {
         "ExampleId": 1255129708,
         "UtteranceText": "i want two large pepperoni pizzas on thin crust"
       },
       "hasError": false
     }
   ]
   

Trenowanie modelu aplikacji Pizza

1. Aby rozpocząć sesję szkoleniową dla aplikacji Pizza, skopiuj to polecenie do edytora tekstów:

   Windows

   curl "***YOUR-AUTHORING-ENDPOINT***/luis/authoring/v3.0-preview/apps/***YOUR-APP-ID***/versions/***YOUR-APP-VERSION***/train?verbose=true&show-all-intents=true" ^
         --data "" ^
         --request POST ^
         --header "Content-Type:application/json" ^
         --header "Ocp-Apim-Subscription-Key: ***YOUR-AUTHORING-KEY***"
   

   macOS

   curl "***YOUR-AUTHORING-ENDPOINT***/luis/authoring/v3.0-preview/apps/***YOUR-APP-ID***/versions/***YOUR-APP-VERSION***/train?verbose=true&show-all-intents=true" \
         --data "" \
         --request POST \
         --header "Content-Type:application/json" \
         --header "Ocp-Apim-Subscription-Key: ***YOUR-AUTHORING-KEY***"
   

   Linux

   curl "***YOUR-AUTHORING-ENDPOINT***/luis/authoring/v3.0-preview/apps/***YOUR-APP-ID***/versions/***YOUR-APP-VERSION***/train?verbose=true&show-all-intents=true" \
         --data "" \
         --request POST \
         --header "Content-Type:application/json" \
         --header "Ocp-Apim-Subscription-Key: ***YOUR-AUTHORING-KEY***"
   

2. Tak jak wcześniej, zastąp ***YOUR- wartości zaczynające się od własnych wartości.

3. Skopiuj polecenie cURL z edytora i wklej je w wierszu polecenia (Windows) lub terminalu (macOS i Linux). Naciśnij klawisz Enter, aby wykonać polecenie.

   Powinna zostać wyświetlona następująca odpowiedź:

   {"statusId":2,"status":"UpToDate"}
   

   Oto dane wyjściowe sformatowane pod kątem czytelności:

   {
     "statusId": 2,
     "status": "UpToDate"
   }
   

Uzyskiwanie stanu szkolenia

1. Aby uzyskać stan trenowania sesji szkoleniowej, skopiuj to polecenie do edytora tekstów:

   Windows

   curl "***YOUR-AUTHORING-ENDPOINT***/luis/authoring/v3.0-preview/apps/***YOUR-APP-ID***/versions/***YOUR-APP-VERSION***/train?verbose=true&show-all-intents=true" ^
           --request GET ^
           --header "Content-Type:application/json" ^
           --header "Ocp-Apim-Subscription-Key: ***YOUR-AUTHORING-KEY***"
   

   macOS

   curl "***YOUR-AUTHORING-ENDPOINT***/luis/authoring/v3.0-preview/apps/***YOUR-APP-ID***/versions/***YOUR-APP-VERSION***/train?verbose=true&show-all-intents=true" \
           --request GET \
           --header "Content-Type:application/json" \
           --header "Ocp-Apim-Subscription-Key: ***YOUR-AUTHORING-KEY***"
   

   Linux

   curl "***YOUR-AUTHORING-ENDPOINT***/luis/authoring/v3.0-preview/apps/***YOUR-APP-ID***/versions/***YOUR-APP-VERSION***/train?verbose=true&show-all-intents=true" \
           --request GET \
           --header "Content-Type:application/json" \
           --header "Ocp-Apim-Subscription-Key: ***YOUR-AUTHORING-KEY***"
   

2. Tak jak wcześniej, zastąp ***YOUR- wartości zaczynające się od własnych wartości.

3. Skopiuj polecenie cURL z edytora i wklej je w wierszu polecenia (Windows) lub terminalu (macOS i Linux). Naciśnij klawisz Enter, aby wykonać polecenie.

   Powinna zostać wyświetlona następująca odpowiedź:

   [{"modelId":"8eb7ad8f-5db5-4c28-819b-ca3905fffd80","details":{"statusId":2,"status":"UpToDate","exampleCount":171}},{"modelId":"6f53bc92-ae54-44ce-bc4e-010d1f8cfda0","details":{"statusId":2,"status":"UpToDate","exampleCount":171}},{"modelId":"6cb17888-ad6e-464c-82c0-d37fd1f2c4f8","details":{"statusId":2,"status":"UpToDate","exampleCount":171}},{"modelId":"a16fc4fd-1949-4e77-9de3-30369f16c3a5","details":{"statusId":2,"status":"UpToDate","exampleCount":171}},{"modelId":"6bacdb75-1889-4f93-8971-8c8995ff8960","details":{"statusId":2,"status":"UpToDate","exampleCount":171}},{"modelId":"be963f4c-4898-48d7-9eba-3c6af0867b9d","details":{"statusId":2,"status":"UpToDate","exampleCount":171}}]
   

   Oto dane wyjściowe sformatowane pod kątem czytelności:

   [
     {
       "modelId": "8eb7ad8f-5db5-4c28-819b-ca3905fffd80",
       "details": {
         "statusId": 2,
         "status": "UpToDate",
         "exampleCount": 171
       }
     },
     {
       "modelId": "6f53bc92-ae54-44ce-bc4e-010d1f8cfda0",
       "details": {
         "statusId": 2,
         "status": "UpToDate",
         "exampleCount": 171
       }
     },
     {
       "modelId": "6cb17888-ad6e-464c-82c0-d37fd1f2c4f8",
       "details": {
         "statusId": 2,
         "status": "UpToDate",
         "exampleCount": 171
       }
     },
     {
       "modelId": "a16fc4fd-1949-4e77-9de3-30369f16c3a5",
       "details": {
         "statusId": 2,
         "status": "UpToDate",
         "exampleCount": 171
       }
     },
     {
       "modelId": "6bacdb75-1889-4f93-8971-8c8995ff8960",
       "details": {
         "statusId": 2,
         "status": "UpToDate",
         "exampleCount": 171
       }
     },
     {
       "modelId": "be963f4c-4898-48d7-9eba-3c6af0867b9d",
       "details": {
         "statusId": 2,
         "status": "UpToDate",
         "exampleCount": 171
       }
     }
   ]
   

Pobieranie intencji z punktu końcowego przewidywania

Użyj narzędzia cURL, aby wysłać zapytanie do punktu końcowego przewidywania i uzyskać wynik przewidywania.

Uwaga

To polecenie używa punktu końcowego przewidywania.

1. Skopiuj to polecenie do edytora tekstów:

   Windows

   curl "https://***YOUR-PREDICTION-ENDPOINT***/luis/prediction/v3.0/apps/***YOUR-APP-ID***/slots/production/predict" ^
         --request GET ^
         --get ^
         --data "subscription-key=***YOUR-PREDICTION-KEY***" ^
         --data "verbose=true" ^
         --data "show-all-intents=true" ^
         --data-urlencode "query=I want two large pepperoni pizzas on thin crust please"
   

   macOS

   curl "https://***YOUR-PREDICTION-ENDPOINT***/luis/prediction/v3.0/apps/***YOUR-APP-ID***/slots/production/predict" \
         --request GET \
         --get \
         --data "subscription-key=***YOUR-PREDICTION-KEY***" \
         --data "verbose=true" \
         --data "show-all-intents=true" \
         --data-urlencode "query=I want two large pepperoni pizzas on thin crust please"
   

   Linux

   curl "https://***YOUR-PREDICTION-ENDPOINT***/luis/prediction/v3.0/apps/***YOUR-APP-ID***/slots/production/predict" \
         --request GET \
         --get \
         --data "subscription-key=***YOUR-PREDICTION-KEY***" \
         --data "verbose=true" \
         --data "show-all-intents=true" \
         --data-urlencode "query=I want two large pepperoni pizzas on thin crust please"
   

2. Zastąp ***YOUR- wartości zaczynające się od własnych wartości.

   Informacja	Purpose
   ***YOUR-PREDICTION-ENDPOINT***	Punkt końcowy adresu URL przewidywania. Znajduje się w portalu usługi LUIS, strona Zasoby platformy Azure dla aplikacji. Na przykład https://westus.api.cognitive.microsoft.com/.
   ***YOUR-APP-ID***	Identyfikator aplikacji. Znajduje się w portalu usługi LUIS, strona Ustawienia aplikacji dla aplikacji.
   ***YOUR-PREDICTION-KEY***	Klucz przewidywania 32 znaków. Znajduje się w portalu usługi LUIS, strona Zasoby platformy Azure dla aplikacji.

3. Skopiuj tekst do okna konsoli i naciśnij klawisz Enter, aby wykonać polecenie:

4. Przejrzyj odpowiedź przewidywania, która jest zwracana w formacie JSON:

   {"query":"I want two large pepperoni pizzas on thin crust please","prediction":{"topIntent":"ModifyOrder","intents":{"ModifyOrder":{"score":1.0},"None":{"score":8.55E-09},"Greetings":{"score":1.82222226E-09},"CancelOrder":{"score":1.47272727E-09},"Confirmation":{"score":9.8125E-10}},"entities":{"Order":[{"FullPizzaWithModifiers":[{"PizzaType":["pepperoni pizzas"],"Size":[["Large"]],"Quantity":[2],"Crust":[["Thin"]],"$instance":{"PizzaType":[{"type":"PizzaType","text":"pepperoni pizzas","startIndex":17,"length":16,"score":0.9978157,"modelTypeId":1,"modelType":"Entity Extractor","recognitionSources":["model"]}],"Size":[{"type":"SizeList","text":"large","startIndex":11,"length":5,"score":0.9984481,"modelTypeId":1,"modelType":"Entity Extractor","recognitionSources":["model"]}],"Quantity":[{"type":"builtin.number","text":"two","startIndex":7,"length":3,"score":0.999770939,"modelTypeId":1,"modelType":"Entity Extractor","recognitionSources":["model"]}],"Crust":[{"type":"CrustList","text":"thin crust","startIndex":37,"length":10,"score":0.933985531,"modelTypeId":1,"modelType":"Entity Extractor","recognitionSources":["model"]}]}}],"$instance":{"FullPizzaWithModifiers":[{"type":"FullPizzaWithModifiers","text":"two large pepperoni pizzas on thin crust","startIndex":7,"length":40,"score":0.90681237,"modelTypeId":1,"modelType":"Entity Extractor","recognitionSources":["model"]}]}}],"ToppingList":[["Pepperoni"]],"$instance":{"Order":[{"type":"Order","text":"two large pepperoni pizzas on thin crust","startIndex":7,"length":40,"score":0.9047088,"modelTypeId":1,"modelType":"Entity Extractor","recognitionSources":["model"]}],"ToppingList":[{"type":"ToppingList","text":"pepperoni","startIndex":17,"length":9,"modelTypeId":5,"modelType":"List Entity Extractor","recognitionSources":["model"]}]}}}}
   

   Odpowiedź JSON sformatowana w celu zapewnienia czytelności:

   {
     "query": "I want two large pepperoni pizzas on thin crust please",
     "prediction": {
       "topIntent": "ModifyOrder",
       "intents": {
         "ModifyOrder": {
           "score": 1.0
         },
         "None": {
           "score": 8.55e-9
         },
         "Greetings": {
           "score": 1.82222226e-9
         },
         "CancelOrder": {
           "score": 1.47272727e-9
         },
         "Confirmation": {
           "score": 9.8125e-10
         }
       },
       "entities": {
         "Order": [
           {
             "FullPizzaWithModifiers": [
               {
                 "PizzaType": [
                   "pepperoni pizzas"
                 ],
                 "Size": [
                   [
                     "Large"
                   ]
                 ],
                 "Quantity": [
                   2
                 ],
                 "Crust": [
                   [
                     "Thin"
                   ]
                 ],
                 "$instance": {
                   "PizzaType": [
                     {
                       "type": "PizzaType",
                       "text": "pepperoni pizzas",
                       "startIndex": 17,
                       "length": 16,
                       "score": 0.9978157,
                       "modelTypeId": 1,
                       "modelType": "Entity Extractor",
                       "recognitionSources": [
                         "model"
                       ]
                     }
                   ],
                   "Size": [
                     {
                       "type": "SizeList",
                       "text": "large",
                       "startIndex": 11,
                       "length": 5,
                       "score": 0.9984481,
                       "modelTypeId": 1,
                       "modelType": "Entity Extractor",
                       "recognitionSources": [
                         "model"
                       ]
                     }
                   ],
                   "Quantity": [
                     {
                       "type": "builtin.number",
                       "text": "two",
                       "startIndex": 7,
                       "length": 3,
                       "score": 0.999770939,
                       "modelTypeId": 1,
                       "modelType": "Entity Extractor",
                       "recognitionSources": [
                         "model"
                       ]
                     }
                   ],
                   "Crust": [
                     {
                       "type": "CrustList",
                       "text": "thin crust",
                       "startIndex": 37,
                       "length": 10,
                       "score": 0.933985531,
                       "modelTypeId": 1,
                       "modelType": "Entity Extractor",
                       "recognitionSources": [
                         "model"
                       ]
                     }
                   ]
                 }
               }
             ],
             "$instance": {
               "FullPizzaWithModifiers": [
                 {
                   "type": "FullPizzaWithModifiers",
                   "text": "two large pepperoni pizzas on thin crust",
                   "startIndex": 7,
                   "length": 40,
                   "score": 0.90681237,
                   "modelTypeId": 1,
                   "modelType": "Entity Extractor",
                   "recognitionSources": [
                     "model"
                   ]
                 }
               ]
             }
           }
         ],
         "ToppingList": [
           [
             "Pepperoni"
           ]
         ],
         "$instance": {
           "Order": [
             {
               "type": "Order",
               "text": "two large pepperoni pizzas on thin crust",
               "startIndex": 7,
               "length": 40,
               "score": 0.9047088,
               "modelTypeId": 1,
               "modelType": "Entity Extractor",
               "recognitionSources": [
                 "model"
               ]
             }
           ],
           "ToppingList": [
             {
               "type": "ToppingList",
               "text": "pepperoni",
               "startIndex": 17,
               "length": 9,
               "modelTypeId": 5,
               "modelType": "List Entity Extractor",
               "recognitionSources": [
                 "model"
               ]
             }
           ]
         }
       }
     }
   }
   

Czyszczenie zasobów

Aplikację można usunąć z portalu usługi LUIS i usunąć zasoby platformy Azure z witryny Azure Portal.

Jeśli używasz interfejsu API REST, usuń ExampleUtterances.JSON plik z systemu plików po zakończeniu pracy z przewodnikiem Szybki start.

Rozwiązywanie problemów

• Uwierzytelnianie w bibliotece klienta — błędy uwierzytelniania zwykle wskazują, że użyto nieprawidłowego klucza i punktu końcowego. Ten przewodnik Szybki start używa klucza tworzenia i punktu końcowego dla środowiska uruchomieniowego przewidywania jako wygody, ale będzie działać tylko wtedy, gdy nie użyto jeszcze miesięcznego limitu przydziału. Jeśli nie możesz użyć klucza tworzenia i punktu końcowego, musisz użyć klucza środowiska uruchomieniowego przewidywania i punktu końcowego podczas uzyskiwania dostępu do biblioteki klienta zestawu SDK środowiska uruchomieniowego przewidywania.
• Tworzenie jednostek — jeśli wystąpi błąd podczas tworzenia zagnieżdżonej jednostki uczenia maszynowego używanej w tym samouczku, upewnij się, że skopiowano kod i nie zmieniono kodu w celu utworzenia innej jednostki.
• Tworzenie przykładowych wypowiedzi — jeśli wystąpi błąd podczas tworzenia oznaczonej etykietą przykładowej wypowiedzi użytej w tym samouczku, upewnij się, że skopiowano kod i nie zmieniono kodu w celu utworzenia innego przykładu oznaczonego etykietą.
• Trenowanie — jeśli wystąpi błąd trenowania, zwykle oznacza to pustą aplikację (bez intencji z przykładowymi wypowiedziami) lub aplikację z intencjami lub jednostkami, które są źle sformułowane.
• Różne błędy — ponieważ kod wywołuje biblioteki klienta z obiektami tekstowymi i obiektami JSON, upewnij się, że kod nie został zmieniony.

Inne błędy — jeśli wystąpi błąd, który nie został omówiony na poprzedniej liście, daj nam znać, przekazując opinię u dołu tej strony. Uwzględnij język programowania i wersję zainstalowanych bibliotek klienckich.

Następne kroki

• Iteracyjne tworzenie aplikacji dla usługi LUIS