Rychlý start: Klientské knihovny služby LUIS (Language Understanding) a rozhraní REST API

Důležité

Služba LUIS bude vyřazena 1. října 2025 a od 1. dubna 2023 nebudete moct vytvářet nové prostředky LUIS. Doporučujeme migrovat aplikace LUIS do porozumění konverzačnímu jazyku, abyste mohli využívat další podporu produktů a vícejazyčné funkce.

V tomto rychlém startu můžete pomocí klientských knihoven sady LUIS SDK vytvořit a dotazovat aplikaci umělé inteligence (AI) služby Azure LUIS pomocí jazyka C#, Pythonu nebo JavaScriptu. K odesílání požadavků pomocí rozhraní REST API můžete také použít cURL.

Služba Language Understanding (LUIS) umožňuje použít zpracování přirozeného jazyka (NLP) na konverzační text uživatele, text přirozeného jazyka, který předpovídá celkový význam a vytáhne relevantní podrobné informace.

• Klientská knihovna pro vytváření a rozhraní REST API umožňují vytvářet, upravovat, trénovat a publikovat aplikaci LUIS.
• Klientská knihovna modulu runtime predikce a rozhraní REST API umožňují dotazovat se na publikovanou aplikaci.

Pomocí klientských knihoven LUIS (Language Understanding) pro .NET můžete:

• Vytvořit aplikaci
• Přidání záměru, strojově naučené entity s ukázkovým výrokem
• Trénovat a publikovat aplikaci
• Modul runtime předpovědi dotazů

Referenční dokumentace | Pro vytváření a predikce – zdrojový kód knihovny | Vytváření a predikce NuGet | Ukázka jazyka C#

Požadavky

• Aktuální verze .NET Core a .NET Core CLI.
• Předplatné Azure: Můžete si ho vytvořit zdarma.
• Jakmile budete mít předplatné Azure, vytvořte na webu Azure Portal prostředek pro vytváření služby Language Understanding, abyste získali klíč a koncový bod. Počkejte, až se nasazení nasadí, a klikněte na tlačítko Přejít k prostředku .
  • K připojení aplikace k vytváření language Understanding budete potřebovat klíč a koncový bod z prostředku, který vytvoříte . Klíč a koncový bod vložíte do kódu níže v rychlém startu. K vyzkoušení služby můžete použít cenovou úroveň Free (F0).

Nastavení

Vytvoření nové aplikace jazyka C#

V preferovaném editoru nebo integrovaném vývojovém prostředí (IDE) vytvořte novou aplikaci .NET Core.

1. V okně konzoly (například cmd, PowerShell nebo Bash) pomocí příkazu dotnet new vytvořte novou konzolovou aplikaci s názvem language-understanding-quickstart. Tento příkaz vytvoří jednoduchý projekt "Hello World" C# s jedním zdrojovým souborem: Program.cs.

   dotnet new console -n language-understanding-quickstart
   

2. Změňte adresář na nově vytvořenou složku aplikace.

   cd language-understanding-quickstart
   

3. Aplikaci můžete sestavit pomocí následujících:

   dotnet build
   

   Výstup sestavení by neměl obsahovat žádná upozornění ani chyby.

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

Instalace knihoven NuGet

V adresáři aplikace nainstalujte klientské knihovny služby Language Understanding (LUIS) pro .NET pomocí následujících příkazů:

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

Vytváření objektového modelu

Klient pro vytváření služby LUIS (Language Understanding) je objekt LUISAuthoringClient , který se ověřuje v Azure, který obsahuje váš klíč pro vytváření.

Příklady kódu pro vytváření

Po vytvoření klienta použijte tohoto klienta pro přístup k funkcím, mezi které patří:

• Aplikace – vytváření, odstraňování, publikování
• Ukázkové promluvy – přidání, odstranění podle ID
• Funkce – správa seznamů frází
• Model – správa záměrů a entit
• Model – správa vzorů
• Trénování – trénování aplikace a dotazování na stav trénování
• Verze – správa pomocí klonování, exportu a odstranění

Prediktivní objektový model

Klient modulu runtime predikce SLUŽBY LUIS (Language Understanding) je objekt LUISRuntimeClient , který se ověřuje v Azure, který obsahuje váš klíč prostředku.

Příklady kódu pro modul runtime predikce

Po vytvoření klienta použijte tohoto klienta pro přístup k funkcím, mezi které patří:

• Předpověď přípravou nebo produkčním slotem
• Předpověď podle verze

Příklady kódu

Tyto fragmenty kódu ukazují, jak pomocí klientské knihovny LUIS (Language Understanding) pro Python provést následující akce:

• Vytvoření aplikace
• Přidat záměr
• Přidání entit
• Přidání ukázkových promluv
• Trénovat aplikaci
• Publikování aplikace
• Předpověď podle slotu

Přidání závislostí

V adresáři projektu otevřete soubor Program.cs v preferovaném editoru nebo integrovaném vývojovém prostředí (IDE). Nahraďte stávající using kód následujícími using direktivami:

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;

Přidání často používaného kódu

1. Změňte podpis Main metody tak, aby povolte asynchronní volání:

   public static async Task Main()
   

2. Přidejte zbytek kódu do Main metody Program třídy, pokud není zadán jinak.

Vytvoření proměnných pro aplikaci

Vytvořte dvě sady proměnných: první sadu, kterou změníte, druhá sada ponechá, jak se zobrazí v ukázce kódu.

Důležité

Nezapomeňte klíč z kódu odebrat, až to budete hotovi, a nikdy ho veřejně neposílejte. V produkčním prostředí použijte bezpečný způsob ukládání přihlašovacích údajů a přístupu k vašim přihlašovacím údajům, jako je Azure Key Vault. Další informace najdete v článku zabezpečení služeb Azure AI.

1. Vytvořte proměnné pro uchovávání názvů klíčů a prostředků pro vytváření.

   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. Vytvořte proměnné pro uložení koncových bodů, názvu aplikace, verze a názvu záměru.

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

Ověření klienta

Vytvořte objekt ApiKeyServiceClientCredentials s klíčem a použijte ho s koncovým bodem k vytvoření objektu LUISAuthoringClient .

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

Vytvoření aplikace LUIS

Aplikace LUIS obsahuje model zpracování přirozeného jazyka (NLP), včetně záměrů, entit a ukázkových promluv.

Vytvořte objekt ApplicationCreateObject. Název a jazyková verze jsou povinné vlastnosti. Volejte metodu Apps.AddAsync . Odpověď je ID aplikace.

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

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

Vytvoření záměru pro aplikaci

Primárním objektem v modelu aplikace LUIS je záměr. Záměr je v souladu se seskupením záměrů promluv uživatele. Uživatel může položit otázku nebo vytvořit příkaz, který hledá konkrétní zamýšlenou odpověď od robota (nebo jiné klientské aplikace). Příklady záměrů si rezervují let, ptají se na počasí v cílovém městě a ptají se na kontaktní informace o zákaznických službách.

Vytvořte ModelCreateObject s názvem jedinečného záměru a pak předejte ID aplikace, ID verze a ModelCreateObject metodě Model.AddIntentAsync. Odpověď je ID záměru.

Hodnota intentName je pevně zakódovaná OrderPizzaIntent jako součást proměnných v části Vytvořit proměnné pro oddíl aplikace .

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

Vytvoření entit pro aplikaci

I když se entity nevyžadují, najdete je ve většině aplikací. Entita extrahuje informace z promluvy uživatele, která je nezbytná k úplnému zadání záměru uživatele. Existuje několik typů předem připravených a vlastních entit, z nichž každý má vlastní modely objektu transformace dat (DTO). Mezi běžné předem připravené entity, které se mají přidat do aplikace, patří číslo, datetimeV2, geographyV2 nebo pořadové číslo.

Je důležité vědět, že entity nejsou označené záměrem. Můžou a obvykle platí pro mnoho záměrů. Pouze ukázkové uživatelské promluvy jsou označené pro konkrétní jediný záměr.

Metody vytváření entit jsou součástí třídy Model . Každý typ entity má svůj vlastní model objektu transformace dat (DTO), který obvykle obsahuje slovo model v oboru názvů Models .

Kód pro vytvoření entity vytvoří entitu strojového učení s dílčími vlastnostmi a funkcemi použitými Quantity u dílčích entit.

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

Pomocí následující metody do třídy vyhledejte ID subentity Quantity, aby bylo možné přiřadit funkce k této podsítě.

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

Přidání ukázkové promluvy do záměru

Aby bylo možné určit záměr promluvy a extrahovat entity, aplikace potřebuje příklady promluv. Příklady musí cílit na konkrétní, jediný záměr a měly by označit všechny vlastní entity. Předem připravené entity nemusí být označené.

Přidejte ukázkové promluvy tak, že vytvoříte seznam objektů ExampleLabelObject , jeden objekt pro každou ukázkovou promluvu. Každý příklad by měl označit všechny entity slovníkem párů názvů/hodnot entity a hodnoty entity. Hodnota entity by měla být přesně tak, jak se zobrazuje v textu ukázkové promluvy.

Volání Examples.AddAsync s ID aplikace, ID verze a příkladem.

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

Trénování aplikace

Po vytvoření modelu je potřeba aplikaci LUIS vytrénovat pro tuto verzi modelu. Vytrénovaný model lze použít v kontejneru nebo publikovat do přípravných nebo produktových slotů.

Metoda Train.TrainVersionAsync potřebuje ID aplikace a ID verze.

Velmi malý model, například tento rychlý start ukazuje, bude trénovat velmi rychle. V případě aplikací na úrovni produkčního prostředí by trénování aplikace mělo zahrnovat volání dotazování na metodu GetStatusAsync , která určí, kdy nebo jestli trénování proběhlo úspěšně. Odpověď je seznam objektů ModelTrainingInfo se samostatným stavem pro každý objekt. Aby bylo trénování považováno za dokončené, musí být všechny objekty úspěšné.

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

Publikování aplikace do produkčního slotu

Publikujte aplikaci LUIS pomocí metody PublishAsync . Tím se publikuje aktuální natrénovaná verze do zadaného slotu v koncovém bodu. Klientská aplikace používá tento koncový bod k odesílání promluv uživatelů pro predikci záměru a extrakce entit.

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

Ověření klienta modulu runtime predikce

Použijte objekt ApiKeyServiceClientCredentials s klíčem a použijte ho s koncovým bodem k vytvoření objektu LUISRuntimeClient.

Upozornění

V tomto rychlém startu se jako součást přihlašovacích údajů modulu runtime používá klíč pro vytváření obsahu. Klíč pro vytváření obsahu může dotazovat modul runtime s několika dotazy. Pro přípravný a produkční kód nahraďte klíč pro vytváření kódem runtime predikce.

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

Získání předpovědi z modulu runtime

Přidejte následující kód pro vytvoření požadavku do modulu runtime předpovědi.

Promluva uživatele je součástí objektu PredictionRequest .

Metoda GetSlotPredictionAsync potřebuje několik parametrů, jako je ID aplikace, název slotu, objekt požadavku predikce pro splnění požadavku. Další možnosti, jako je podrobné zobrazení všech záměrů a protokol, jsou volitelné.

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

Odpověď předpovědi je objekt JSON, včetně záměru a nalezených entit.

{
    "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"
                        ]
                    }
                ]
            }
        }
    }
}

Spuštění aplikace

Spusťte aplikaci příkazem dotnet run z adresáře aplikace.

dotnet run

Pomocí klientských knihoven LUIS (Language Understanding) můžete Node.js provádět následující:

• Vytvořit aplikaci
• Přidání záměru, strojově naučené entity s ukázkovým výrokem
• Trénovat a publikovat aplikaci
• Modul runtime předpovědi dotazů

Referenční dokumentace | Pro tvorbu a predikci NPM | Vzorky

Požadavky

• Node.js
• Předplatné Azure: Můžete si ho vytvořit zdarma.
• Jakmile budete mít předplatné Azure, vytvořte na webu Azure Portal prostředek pro vytváření služby Language Understanding, abyste získali klíč a koncový bod. Počkejte, až se nasazení nasadí, a klikněte na tlačítko Přejít k prostředku .
  • K připojení aplikace k vytváření language Understanding budete potřebovat klíč a koncový bod z prostředku, který vytvoříte . Klíč a koncový bod vložíte do kódu níže v rychlém startu. K vyzkoušení služby můžete použít cenovou úroveň Free (F0).

Nastavení

Vytvoření nové javascriptové aplikace

1. V okně konzoly vytvořte nový adresář pro vaši aplikaci a přejděte do daného adresáře.

   mkdir quickstart-sdk && cd quickstart-sdk
   

2. Inicializace adresáře jako javascriptové aplikace vytvořením package.json souboru

   npm init -y
   

3. Vytvořte soubor s názvem index.js pro kód JavaScriptu.

   touch index.js
   

Instalace knihoven NPM

V adresáři aplikace nainstalujte závislosti s následujícími příkazy a spusťte najednou jeden řádek:

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

Měl package.json by vypadat takto:

{
  "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"
  }
}

Vytváření objektového modelu

Klient pro vytváření služby LUIS (Language Understanding) je objekt LUISAuthoringClient , který se ověřuje v Azure, který obsahuje váš klíč pro vytváření.

Příklady kódu pro vytváření

Po vytvoření klienta použijte tohoto klienta pro přístup k funkcím, mezi které patří:

• Aplikace – přidání, odstranění, publikování
• Ukázkové promluvy – přidání podle dávky, odstranění podle ID
• Funkce – správa seznamů frází
• Model – správa záměrů a entit
• Model – správa vzorů
• Trénování – trénování aplikace a dotazování na stav trénování
• Verze – správa pomocí klonování, exportu a odstranění

Prediktivní objektový model

Klient pro vytváření služby LUIS (Language Understanding) je objekt LUISAuthoringClient , který se ověřuje v Azure, který obsahuje váš klíč pro vytváření.

Příklady kódu pro modul runtime predikce

Po vytvoření klienta použijte tohoto klienta pro přístup k funkcím, mezi které patří:

• Predikce podle staging nebo production slotu
• Předpověď podle verze

Příklady kódu

Tyto fragmenty kódu ukazují, jak pomocí klientské knihovny LUIS (Language Understanding) pro Python provést následující akce:

• Vytvoření aplikace
• Přidat záměr
• Přidání entit
• Přidání ukázkových promluv
• Trénovat aplikaci
• Publikování aplikace
• Předpověď podle slotu

Přidání závislostí

Otevřete soubor v preferovaném editoru nebo integrovaném index.js vývojovém prostředí s názvem a přidejte následující závislosti.

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

Přidání často používaného kódu

1. Přidejte metodu quickstart a její volání. Tato metoda obsahuje většinu zbývajícího kódu. Tato metoda se volá na konci souboru.

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

2. Přidejte zbývající kód v metodě rychlého startu, pokud není zadán jinak.

Vytvoření proměnných pro aplikaci

Vytvořte dvě sady proměnných: první sadu, kterou změníte, druhá sada ponechá, jak se zobrazí v ukázce kódu.

Důležité

Nezapomeňte klíč z kódu odebrat, až to budete hotovi, a nikdy ho veřejně neposílejte. V produkčním prostředí použijte bezpečný způsob ukládání přihlašovacích údajů a přístupu k vašim přihlašovacím údajům, jako je Azure Key Vault. Další informace najdete v článku zabezpečení služeb Azure AI.

1. Vytvořte proměnné pro uchovávání názvů klíčů a prostředků pro vytváření.

   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. Vytvořte proměnné pro uložení koncových bodů, názvu aplikace, verze a názvu záměru.

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

Ověření klienta

Vytvořte objekt CognitiveServicesCredentials s klíčem a použijte ho s koncovým bodem k vytvoření objektu LUISAuthoringClient .

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

Vytvoření aplikace LUIS

Aplikace LUIS obsahuje model zpracování přirozeného jazyka (NLP), včetně záměrů, entit a ukázkových promluv.

Vytvořte metodu přidání objektu AppsOperation pro vytvoření aplikace. Název a jazyková verze jsou povinné vlastnosti.

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

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

const appId = createAppResult.body

Vytvoření záměru pro aplikaci

Primárním objektem v modelu aplikace LUIS je záměr. Záměr je v souladu se seskupením záměrů promluv uživatele. Uživatel může položit otázku nebo vytvořit příkaz, který hledá konkrétní zamýšlenou odpověď od robota (nebo jiné klientské aplikace). Příklady záměrů si rezervují let, ptají se na počasí v cílovém městě a ptají se na kontaktní informace o zákaznických službách.

Použijte metodu model.add_intent s názvem jedinečného záměru a pak předejte ID aplikace, ID verze a název nového záměru.

Hodnota intentName je pevně zakódovaná OrderPizzaIntent jako součást proměnných v části Vytvořit proměnné pro oddíl aplikace .

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

Vytvoření entit pro aplikaci

I když se entity nevyžadují, najdete je ve většině aplikací. Entita extrahuje informace z promluvy uživatele, která je nezbytná k úplnému zadání záměru uživatele. Existuje několik typů předem připravených a vlastních entit, z nichž každý má vlastní modely objektu transformace dat (DTO). Mezi běžné předem připravené entity, které se mají přidat do aplikace, patří číslo, datetimeV2, geographyV2 nebo pořadové číslo.

Je důležité vědět, že entity nejsou označené záměrem. Můžou a obvykle platí pro mnoho záměrů. Pouze ukázkové promluvy uživatelů jsou označené pro konkrétní jediný záměr.

Metody vytváření entit jsou součástí třídy Model . Každý typ entity má svůj vlastní model objektu transformace dat (DTO).

Kód pro vytvoření entity vytvoří entitu strojového učení s dílčími vlastnostmi a funkcemi použitými Quantity u dílčích entit.

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

Přiřaďte následující metodu nad metodu quickstart , abyste našli ID subentity Quantity, aby bylo možné přiřadit funkce k dané podsítě.

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

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

}

Přidání ukázkové promluvy do záměru

Aby bylo možné určit záměr promluvy a extrahovat entity, aplikace potřebuje příklady promluv. Příklady musí cílit na konkrétní, jediný záměr a měly by označit všechny vlastní entity. Předem připravené entity nemusí být označené.

Přidejte ukázkové promluvy tak, že vytvoříte seznam objektů ExampleLabelObject, jeden objekt pro každou ukázkovou promluvu. Každý příklad by měl označit všechny entity slovníkem párů názvů/hodnot entity a hodnoty entity. Hodnota entity by měla být přesně tak, jak se zobrazuje v textu ukázkové promluvy.

Zavolejte examples.add s ID aplikace, ID verze a příkladem.

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

Trénování aplikace

Po vytvoření modelu je potřeba aplikaci LUIS vytrénovat pro tuto verzi modelu. Vytrénovaný model lze použít v kontejneru nebo publikovat do přípravných nebo produktových slotů.

Metoda train.trainVersion potřebuje ID aplikace a ID verze.

Velmi malý model, například tento rychlý start ukazuje, bude trénovat velmi rychle. V případě aplikací na úrovni produkčního prostředí by trénování aplikace mělo zahrnovat volání dotazování na metodu get_status , která určí, kdy nebo jestli trénování proběhlo úspěšně. Odpověď je seznam objektů ModelTrainingInfo se samostatným stavem pro každý objekt. Aby bylo trénování považováno za dokončené, musí být všechny objekty úspěšné.

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

Publikování aplikace do produkčního slotu

Publikujte aplikaci LUIS pomocí metody app.publish . Tím se publikuje aktuální natrénovaná verze do zadaného slotu v koncovém bodu. Klientská aplikace používá tento koncový bod k odesílání promluv uživatelů pro predikci záměru a extrakce entit.

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

Ověření klienta modulu runtime predikce

Použijte objekt msRest.ApiKeyCredentials s klíčem a použijte ho s koncovým bodem k vytvoření služby LUIS. OBJEKT LUISRuntimeClient .

Upozornění

V tomto rychlém startu se jako součást přihlašovacích údajů modulu runtime používá klíč pro vytváření obsahu. Klíč pro vytváření obsahu může dotazovat modul runtime s několika dotazy. Pro přípravný a produkční kód nahraďte klíč pro vytváření kódem runtime predikce.

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

Získání předpovědi z modulu runtime

Přidejte následující kód pro vytvoření požadavku do modulu runtime předpovědi. Promluva uživatele je součástí objektu predictionRequest.

Metoda luisRuntimeClient.prediction.getSlotPrediction potřebuje několik parametrů, jako je ID aplikace, název slotu a objekt požadavku predikce, který požadavek splní. Další možnosti, jako je podrobné zobrazení všech záměrů a protokol, jsou volitelné.

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

Odpověď předpovědi je objekt JSON, včetně záměru a nalezených entit.

{
    "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"
                        ]
                    }
                ]
            }
        }
    }
}

Spuštění aplikace

Spusťte aplikaci pomocí příkazu node index.js pro soubor rychlého startu.

node index.js

Pomocí klientských knihoven LUIS (Language Understanding) pro Python můžete:

• Vytvořit aplikaci
• Přidání záměru, strojově naučené entity s ukázkovým výrokem
• Trénovat a publikovat aplikaci
• Modul runtime předpovědi dotazů

Referenční dokumentace | Pro vytváření a predikce – zdrojový kód knihovny | Ukázky balíčku (Pypi) |

Požadavky

• Aktuální verze Pythonu 3.x.
• Předplatné Azure: Můžete si ho vytvořit zdarma.
• Jakmile budete mít předplatné Azure, vytvořte na webu Azure Portal prostředek pro vytváření služby Language Understanding, abyste získali klíč a koncový bod. Počkejte, až se nasazení nasadí, a klikněte na tlačítko Přejít k prostředku .
  • K připojení aplikace k vytváření language Understanding budete potřebovat klíč a koncový bod z prostředku, který vytvoříte . Klíč a koncový bod vložíte do kódu níže v rychlém startu. K vyzkoušení služby můžete použít cenovou úroveň Free (F0).

Nastavení

Vytvoření nové aplikace v Pythonu

1. V okně konzoly vytvořte nový adresář pro vaši aplikaci a přejděte do daného adresáře.

   mkdir quickstart-sdk && cd quickstart-sdk
   

2. Vytvořte soubor s názvem authoring_and_predict.py pro kód Pythonu.

   touch authoring_and_predict.py
   

Instalace klientské knihovny pomocí pipu

V adresáři aplikace nainstalujte klientskou knihovnu LUIS (Language Understanding) pro Python pomocí následujícího příkazu:

pip install azure-cognitiveservices-language-luis

Vytváření objektového modelu

Klient pro vytváření služby LUIS (Language Understanding) je objekt LUISAuthoringClient , který se ověřuje v Azure, který obsahuje váš klíč pro vytváření.

Příklady kódu pro vytváření

Po vytvoření klienta použijte tohoto klienta pro přístup k funkcím, mezi které patří:

• Aplikace – vytváření, odstraňování, publikování
• Ukázkové promluvy – přidání podle dávky, odstranění podle ID
• Funkce – správa seznamů frází
• Model – správa záměrů a entit
• Model – správa vzorů
• Trénování – trénování aplikace a dotazování na stav trénování
• Verze – správa pomocí klonování, exportu a odstranění

Prediktivní objektový model

Klient modulu runtime predikce SLUŽBY LUIS (Language Understanding) je objekt LUISRuntimeClient , který se ověřuje v Azure, který obsahuje váš klíč prostředku.

Příklady kódu pro modul runtime predikce

Po vytvoření klienta použijte tohoto klienta pro přístup k funkcím, mezi které patří:

• Předpověď přípravou nebo produkčním slotem
• Předpověď podle verze

Příklady kódu

Tyto fragmenty kódu ukazují, jak pomocí klientské knihovny LUIS (Language Understanding) pro Python provést následující akce:

• Vytvoření aplikace
• Přidat záměr
• Přidání entit
• Přidání ukázkových promluv
• Trénovat aplikaci
• Publikování aplikace
• Předpověď podle slotu

Přidání závislostí

Přidejte klientské knihovny do souboru Pythonu.

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

Přidání často používaného kódu

1. Přidejte metodu quickstart a její volání. Tato metoda obsahuje většinu zbývajícího kódu. Tato metoda se volá na konci souboru.

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

2. Přidejte zbývající kód v metodě rychlého startu, pokud není zadán jinak.

Vytvoření proměnných pro aplikaci

Vytvořte dvě sady proměnných: první sadu, kterou změníte, druhá sada ponechá, jak se zobrazí v ukázce kódu.

Důležité

Nezapomeňte klíč z kódu odebrat, až to budete hotovi, a nikdy ho veřejně neposílejte. V produkčním prostředí použijte bezpečný způsob ukládání přihlašovacích údajů a přístupu k vašim přihlašovacím údajům, jako je Azure Key Vault. Další informace najdete v článku zabezpečení služeb Azure AI.

1. Vytvořte proměnné pro uchovávání názvů klíčů a prostředků pro vytváření.

   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. Vytvořte proměnné pro uložení koncových bodů, názvu aplikace, verze a názvu záměru.

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

Ověření klienta

Vytvořte objekt CognitiveServicesCredentials s klíčem a použijte ho s koncovým bodem k vytvoření objektu LUISAuthoringClient .

client = LUISAuthoringClient(authoringEndpoint, CognitiveServicesCredentials(authoringKey))

Vytvoření aplikace LUIS

Aplikace LUIS obsahuje model zpracování přirozeného jazyka (NLP), včetně záměrů, entit a ukázkových promluv.

Vytvořte metodu přidání objektu AppsOperation pro vytvoření aplikace. Název a jazyková verze jsou povinné vlastnosti.

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

Vytvoření záměru pro aplikaci

Primárním objektem v modelu aplikace LUIS je záměr. Záměr je v souladu se seskupením záměrů promluv uživatele. Uživatel může položit otázku nebo vytvořit příkaz, který hledá konkrétní zamýšlenou odpověď od robota (nebo jiné klientské aplikace). Příklady záměrů si rezervují let, ptají se na počasí v cílovém městě a ptají se na kontaktní informace o zákaznických službách.

Použijte metodu model.add_intent s názvem jedinečného záměru a pak předejte ID aplikace, ID verze a název nového záměru.

Hodnota intentName je pevně zakódovaná OrderPizzaIntent jako součást proměnných v části Vytvořit proměnné pro oddíl aplikace .

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

Vytvoření entit pro aplikaci

I když se entity nevyžadují, najdete je ve většině aplikací. Entita extrahuje informace z promluvy uživatele, která je nezbytná k úplnému zadání záměru uživatele. Existuje několik typů předem připravených a vlastních entit, z nichž každý má vlastní modely objektu transformace dat (DTO). Mezi běžné předem připravené entity, které se mají přidat do aplikace, patří číslo, datetimeV2, geographyV2 nebo pořadové číslo.

Je důležité vědět, že entity nejsou označené záměrem. Můžou a obvykle platí pro mnoho záměrů. Pouze ukázkové promluvy uživatelů jsou označené pro konkrétní jediný záměr.

Metody vytváření entit jsou součástí třídy ModelOperations . Každý typ entity má svůj vlastní model objektu transformace dat (DTO).

Kód pro vytvoření entity vytvoří entitu strojového učení s dílčími vlastnostmi a funkcemi použitými Quantity u dílčích entit.

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

Přiřaďte následující metodu nad metodu quickstart , abyste našli ID subentity Quantity, aby bylo možné přiřadit funkce k dané podsítě.

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

Přidání ukázkové promluvy do záměru

Aby bylo možné určit záměr promluvy a extrahovat entity, aplikace potřebuje příklady promluv. Příklady musí cílit na konkrétní, jediný záměr a měly by označit všechny vlastní entity. Předem připravené entity nemusí být označené.

Přidejte ukázkové promluvy tak, že vytvoříte seznam objektů ExampleLabelObject , jeden objekt pro každou ukázkovou promluvu. Každý příklad by měl označit všechny entity slovníkem párů názvů/hodnot entity a hodnoty entity. Hodnota entity by měla být přesně tak, jak se zobrazuje v textu ukázkové promluvy.

Zavolejte examples.add s ID aplikace, ID verze a příkladem.

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

Trénování aplikace

Po vytvoření modelu je potřeba aplikaci LUIS vytrénovat pro tuto verzi modelu. Vytrénovaný model lze použít v kontejneru nebo publikovat do přípravných nebo produktových slotů.

Metoda train.train_version potřebuje ID aplikace a ID verze.

Velmi malý model, například tento rychlý start ukazuje, bude trénovat velmi rychle. V případě aplikací na úrovni produkčního prostředí by trénování aplikace mělo zahrnovat volání dotazování na metodu get_status , která určí, kdy nebo jestli trénování proběhlo úspěšně. Odpověď je seznam objektů ModelTrainingInfo se samostatným stavem pro každý objekt. Aby bylo trénování považováno za dokončené, musí být všechny objekty úspěšné.

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

Publikování aplikace do produkčního slotu

Publikujte aplikaci LUIS pomocí metody app.publish . Tím se publikuje aktuální natrénovaná verze do zadaného slotu v koncovém bodu. Klientská aplikace používá tento koncový bod k odesílání promluv uživatelů pro predikci záměru a extrakce entit.

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

Ověření klienta modulu runtime predikce

Použijte objekt přihlašovacích údajů s klíčem a použijte ho s koncovým bodem k vytvoření objektu LUISRuntimeClientConfiguration .

Upozornění

V tomto rychlém startu se jako součást přihlašovacích údajů modulu runtime používá klíč pro vytváření obsahu. Klíč pro vytváření obsahu může dotazovat modul runtime s několika dotazy. Pro přípravný a produkční kód nahraďte klíč pro vytváření kódem runtime predikce.

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

Získání předpovědi z modulu runtime

Přidejte následující kód pro vytvoření požadavku do modulu runtime předpovědi.

Promluva uživatele je součástí objektu prediction_request .

Metoda get_slot_prediction potřebuje několik parametrů, jako je ID aplikace, název slotu a objekt požadavku predikce pro splnění požadavku. Další možnosti, jako je podrobné zobrazení všech záměrů a protokol, jsou volitelné. Požadavek vrátí objekt 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))

Odpověď předpovědi je objekt JSON, včetně záměru a nalezených entit.

{
    "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"
                        ]
                    }
                ]
            }
        }
    }
}

Spuštění aplikace

Spusťte aplikaci pomocí příkazu python pro soubor rychlého startu.

python authoring_and_predict.py

V tomto rychlém startu provedete postupně tři volání REST.

• Nejprve nahrajete dávku ukázkových promluv, které se použijí k trénování modelu aplikace Pizza pomocí volání popisků REST Batch.
• V dalším kroku zahájíte trénovací relaci pro aplikaci Pizza pomocí volání verze aplikace REST Train.
• Nakonec získáte stav trénovací relace pro aplikaci Pizza pomocí volání stavu trénování verze REST Get.

Referenční dokumentace

Požadavky

• Bezplatný účet LUIS .

• Textový editor, jako je Visual Studio Code.

• Program příkazového řádku cURL. Program cURL je již nainstalovaný v systému macOS, většina linuxových distribucí a Windows 10 build 1803 a novější.

  Pokud potřebujete nainstalovat cURL, můžete si cURL stáhnout ze stránky pro stažení cURL.

Vytvoření aplikace Pizza

Vytvořte aplikaci pizza.

1. Výběrem pizza-app-for-luis-v6.json otevřete stránku GitHubu pro pizza-app-for-luis.json soubor.
2. Klikněte pravým tlačítkem myši nebo dlouho klepněte na tlačítko Nezpracované a vyberte Uložit odkaz, abyste ho uložili pizza-app-for-luis.json do počítače.
3. Přihlaste se k portálu LUIS.
4. Vyberte Moje aplikace.
5. Na stránce Moje aplikace vyberte + Nová aplikace pro konverzaci.
6. Vyberte Importovat jako JSON.
7. V dialogovém okně Importovat novou aplikaci vyberte tlačítko Zvolit soubor .
8. pizza-app-for-luis.json Vyberte stažený soubor a pak vyberte Otevřít.
9. Do pole Název dialogového okna Importovat novou aplikaci zadejte název aplikace Pizza a pak vyberte tlačítko Hotovo.

Aplikace se naimportuje.

Pokud se zobrazí dialogové okno Jak vytvořit efektivní aplikaci LUIS, zavřete dialogové okno.

Trénovat a publikovat aplikaci Pizza

Měla by se zobrazit stránka Záměry se seznamem záměrů v aplikaci Pizza.

1. V pravém horním rohu webu LUIS vyberte tlačítko Trénovat .

   

2. Trénování se dokončí, když je tlačítko Trénovat zakázané.

Pokud chcete přijímat predikce luis v chatovacím robotovi nebo v jiných klientských aplikacích, musíte aplikaci publikovat do koncového bodu předpovědi.

1. V pravém horním navigačním panelu vyberte Publikovat .

   

2. Vyberte produkční slot a pak vyberte Hotovo.

   

3. V oznámení vyberte Přístup k adresám URL koncového bodu a přejděte na stránku Prostředky Azure. Adresy URL uvidíte jenom v případě, že máte k aplikaci přidružený prostředek predikce. Stránku Prostředky Azure najdete také kliknutím na Spravovat.

   

Přidání prostředku pro vytváření obsahu do aplikace Pizza

1. Vyberte SPRAVOVAT.
2. Vyberte Azure Resources (Prostředky Azure).
3. Vyberte Zdroj pro vytváření obsahu.
4. Vyberte Změnit prostředek pro vytváření obsahu.

Pokud máte prostředek pro vytváření obsahu, zadejte název tenanta, název předplatného a název prostředku luis vašeho prostředku pro vytváření.

Pokud nemáte prostředek pro vytváření obsahu:

1. Vyberte Vytvořit nový prostředek.
2. Zadejte název tenanta, název prostředku, název předplatného a název skupiny prostředků Azure.

Vaše aplikace Pizza je teď připravená k použití.

Zaznamenávání přístupových hodnot pro vaši aplikaci Pizza

Pokud chcete použít novou aplikaci Pizza, budete potřebovat ID aplikace, klíč pro vytváření a koncový bod pro vytváření vaší aplikace Pizza. K získání předpovědí budete potřebovat samostatný koncový bod předpovědi a klíč předpovědi.

Tyto hodnoty najdete takto:

1. Na stránce Záměry vyberte SPRAVOVAT.
2. Na stránce Nastavení aplikace poznamenejte ID aplikace.
3. Vyberte Azure Resources (Prostředky Azure).
4. Vyberte Zdroj pro vytváření obsahu.
5. Na kartách Zdroje pro vytváření obsahu a Prostředky predikce si poznamenejte primární klíč. Tato hodnota je váš klíč pro vytváření.
6. Zaznamenejte adresu URL koncového bodu. Tato hodnota je váš koncový bod pro vytváření.

Vytvoření souboru JSON pro trénovat aplikaci Pizza

Pokud chcete vytvořit soubor JSON se třemi ukázkovými promluvami, uložte následující data JSON do souboru s názvem 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
      }
    ]
  }
]`

Ukázkový kód JSON promluv se řídí konkrétním formátem.

Pole text obsahuje text ukázkové promluvy. Pole intentName musí odpovídat názvu existujícího záměru v aplikaci LUIS. Pole entityLabels je povinné. Pokud nechcete označovat žádné entity, zadejte prázdné pole.

Není-li pole entityLabels prázdné, hodnoty startCharIndex a endCharIndex musí označovat entitu, na kterou odkazuje pole entityName. Index je založený na nule. Pokud začnete nebo ukončíte popisek v mezerě v textu, volání rozhraní API pro přidání promluv se nezdaří.

Přidat ukázkové promluvy

1. Pokud chcete nahrát dávku ukázkových promluv, zkopírujte tento příkaz do textového editoru:

   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. Nahraďte hodnoty začínající vlastními ***YOUR- hodnotami.

   Informační	Účel
   ***YOUR-AUTHORING-ENDPOINT***	Koncový bod adresy URL pro vytváření Například "https://REPLACE-WITH-YOUR-RESOURCE-NAME.api.cognitive.microsoft.com/". Název prostředku nastavíte při vytváření prostředku.
   ***YOUR-APP-ID***	ID vaší aplikace LUIS.
   ***YOUR-APP-VERSION***	Vaše verze aplikace LUIS Pro aplikaci Pizza je číslo verze "0.1" bez uvozovek.
   ***YOUR-AUTHORING-KEY***	Váš klíč pro vytváření 32 znaků.

   Přiřazené klíče a prostředky jsou viditelné na portálu LUIS v části Správa na stránce prostředky Azure. ID aplikace je k dispozici ve stejné části Správa na stránce Nastavení aplikace.

   Důležité

   Nezapomeňte klíč z kódu odebrat, až to budete hotovi, a nikdy ho veřejně neposílejte. V produkčním prostředí použijte bezpečný způsob ukládání přihlašovacích údajů a přístupu k vašim přihlašovacím údajům, jako je Azure Key Vault. Další informace najdete v článku zabezpečení služeb Azure AI.

3. Spusťte příkazový řádek (Windows) nebo terminál (macOS a Linux) a změňte adresáře na stejný adresář, do kterého jste soubor uložili ExampleUtterances.JSON .

4. Zkopírujte příkaz cURL z editoru a vložte ho do příkazového řádku (Windows) nebo terminálu (macOS a Linux). Stisknutím klávesy Enter spusťte příkaz.

   Měla by se zobrazit následující odpověď:

   [{"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}]
   

   Tady je výstup formátovaný pro čitelnost:

   [
     {
       "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
     }
   ]
   

Trénování modelu aplikace Pizza

1. Pokud chcete zahájit trénovací relaci pro aplikaci Pizza, zkopírujte tento příkaz do textového editoru:

   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. Stejně jako předtím nahraďte hodnoty začínající vlastními ***YOUR- hodnotami.

3. Zkopírujte příkaz cURL z editoru a vložte ho do příkazového řádku (Windows) nebo terminálu (macOS a Linux). Stisknutím klávesy Enter spusťte příkaz.

   Měla by se zobrazit následující odpověď:

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

   Tady je výstup formátovaný pro čitelnost:

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

Získání stavu trénování

1. Pokud chcete získat stav trénování pro trénovací relaci, zkopírujte tento příkaz do textového editoru:

   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. Stejně jako předtím nahraďte hodnoty začínající vlastními ***YOUR- hodnotami.

3. Zkopírujte příkaz cURL z editoru a vložte ho do příkazového řádku (Windows) nebo terminálu (macOS a Linux). Stisknutím klávesy Enter spusťte příkaz.

   Měla by se zobrazit následující odpověď:

   [{"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}}]
   

   Tady je výstup formátovaný pro čitelnost:

   [
     {
       "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
       }
     }
   ]
   

Získání záměru z koncového bodu předpovědi

Pomocí cURL zadejte dotaz na koncový bod předpovědi a získejte výsledek předpovědi.

Poznámka:

Tento příkaz používá koncový bod předpovědi.

1. Zkopírujte tento příkaz do textového editoru:

   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. Nahraďte hodnoty začínající vlastními ***YOUR- hodnotami.

   Informační	Účel
   ***YOUR-PREDICTION-ENDPOINT***	Koncový bod adresy URL předpovědi. Nachází se na portálu LUIS a na stránce Prostředky Azure pro vaši aplikaci. Například https://westus.api.cognitive.microsoft.com/.
   ***YOUR-APP-ID***	ID vaší aplikace. Nachází se na portálu LUIS a na stránce Nastavení aplikace pro vaši aplikaci.
   ***YOUR-PREDICTION-KEY***	Váš prediktivní klíč 32 znaků. Nachází se na portálu LUIS a na stránce Prostředky Azure pro vaši aplikaci.

3. Zkopírujte text do okna konzoly a stisknutím klávesy Enter spusťte příkaz:

4. Zkontrolujte odpověď predikce, která se vrátí jako 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"]}]}}}}
   

   Odpověď JSON naformátovaná pro čitelnost:

   {
     "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"
               ]
             }
           ]
         }
       }
     }
   }
   

Vyčištění prostředků

Aplikaci můžete odstranit z portálu LUIS a odstranit prostředky Azure z webu Azure Portal.

Pokud používáte rozhraní REST API, odstraňte ExampleUtterances.JSON soubor ze systému souborů, až to budete mít v rychlém startu.

Řešení problému

• Ověřování v klientské knihovně – chyby ověřování obvykle značí, že se použil nesprávný klíč a koncový bod. V tomto rychlém startu se jako pohodlí používá klíč pro vytváření obsahu a koncový bod pro modul runtime predikce, ale bude fungovat jenom v případě, že jste měsíční kvótu ještě nepoužili. Pokud nemůžete použít klíč a koncový bod pro vytváření obsahu, musíte použít klíč modulu runtime předpovědi a koncový bod při přístupu k klientské knihovně sady SDK pro predikční modul runtime.
• Vytváření entit – pokud dojde k chybě při vytváření vnořené entity strojového učení použité v tomto kurzu, ujistěte se, že jste kód zkopírovali a nezměnili jste kód tak, aby se vytvořila jiná entita.
• Vytváření ukázkových promluv – pokud se zobrazí chyba při vytváření ukázkové promluvy s popiskem použitým v tomto kurzu, ujistěte se, že jste kód zkopírovali a nezměnili jste kód a vytvořili jiný příklad s popiskem.
• Školení – pokud dojde k chybě trénování, obvykle to značí prázdnou aplikaci (bez záměrů s ukázkovými promluvami) nebo aplikaci se záměry nebo entitami, které jsou poškozené.
• Různé chyby – protože volání kódu do klientských knihoven s textem a objekty JSON, ujistěte se, že jste kód nezměnili.

Další chyby – pokud se zobrazí chyba, která není uvedená v předchozím seznamu, dejte nám vědět tím, že nám poskytnete zpětnou vazbu v dolní části této stránky. Zahrňte programovací jazyk a verzi klientských knihoven, které jste nainstalovali.

Další kroky

• Iterativní vývoj aplikací pro SLUŽBU LUIS