Rychlý start: Language Understanding (LUIS) klientské knihovny a REST API

  • Článek
  • 39 min ke čtení

Poznámka

Novější verze funkcí Language Understanding je teď dostupná jako součást služby Azure Cognitive Service for Language. Další informace najdete v dokumentaci ke službě Azure Cognitive Service for Language. Možnosti porozumění jazyku ve službě Language Service najdete v tématu Konverzační Language Understanding, VlastníRozpoznání pojmenovaných entit a Vlastní klasifikace.

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

Language Understanding (LUIS) umožňuje použít zpracování přirozeného jazyka (NLP) na konverzační text uživatele v přirozeném jazyce k predikci celkového významu a vytažení relevantních podrobných informací.

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

Použijte klientské knihovny Language Understanding (LUIS) pro rozhraní .NET pro:

  • Vytvoření aplikace
  • Přidejte záměr, počítačově získanou entitu s příkladem utterance
  • Výuka a publikování aplikace
  • Modul runtime předpovědi dotazů

Referenční dokumentace | Zdrojový kód knihovny pro vytváření a předpovědi | Vytváření a předpověď NuGet | Ukázka jazyka C#

Požadavky

  • Aktuální verze rozhraní .NET Core a .NET Core CLI.
  • Předplatné Azure – Vytvořte si ho zdarma .
  • Jakmile budete mít předplatné Azure, vytvořte v Azure Portal prostředek pro vytváření Language Understanding , abyste získali svůj klíč a koncový bod. Počkejte na nasazení a klikněte na tlačítko Přejít k prostředku .
    • Pro připojení aplikace k Language Understanding vytváření obsahu budete potřebovat klíč a koncový bod z prostředku, který vytvoříte . Svůj klíč a koncový bod vložíte do níže uvedeného kódu později v rychlém startu. Službu můžete vyzkoušet pomocí bezplatné cenové úrovně ( F0 ).

Nastavení

Vytvoření nové aplikace v C#

Vytvořte novou aplikaci .NET Core v upřednostňovaném editoru nebo integrovaném vývojovém prostředí (IDE).

  1. V okně konzoly (například cmd, PowerShell nebo bash) new vytvořte pomocí příkazu dotnet novou konzolovou aplikaci s názvem language-understanding-quickstart . Tento příkaz vytvoří jednoduchý projekt C# "Hello World" 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 vytvořit pomocí:

    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 Language Understanding (LUIS) je objekt LUISAuthoringClient, který se ověřuje v Azure a obsahuje 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ří:

Predikční objektový model

Klient modulu runtime Language Understanding předpovědi (LUIS) je objekt LUISRuntimeClient, který se ověřuje v Azure a obsahuje váš klíč prostředku.

Příklady kódu pro modul runtime predikcí

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

Příklady kódu

Tyto fragmenty kódu ukazují, jak provést následující s klientskou knihovnou Language Understanding (LUIS) pro Python:

Přidání závislostí

V adresáři projektu otevřete soubor Program.cs v upřednostňovaném editoru nebo integrovaném vývojovém prostředí. Nahraďte existují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řidat často používaný kód

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

    public static async Task Main()

  2. Pokud není uvedeno jinak, přidejte zbytek kódu do Main metody Program třídy.

Vytvoření proměnných pro aplikaci

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

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

    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 u svého koncového bodu 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 NLP (přirozený jazyk Processing), včetně záměrů, entit a příkladu projevy.

Vytvořte ApplicationCreateObject. Název a jazyková verze jazyka jsou požadované vlastnosti. Zavolejte 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řit záměr pro aplikaci

Primárním objektem v modelu aplikace LUIS je záměr. Záměr se zarovnává se seskupením záměrů uživatelů utterance. Uživatel může požádat o dotaz nebo vytvořit příkaz, který hledá konkrétní zamýšlenou odpověď z robota (nebo jiné klientské aplikace). Příklady záměrů je vyúčtování letu, dotazování na počasí v cílovém městě a dotazování na kontaktní informace pro zákaznické služby.

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

Hodnota je v rámci proměnných v části Vytvoření proměnných pro intentName OrderPizzaIntent aplikaci naceněná na .

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

Vytváření entit pro aplikaci

I když se entity nepožaduje, nacházejí se ve většině aplikací. Entita extrahuje informace z protterance uživatele, které jsou nezbytné k úplnému vyhově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 objektů transformace dat (DTO). Mezi běžné předem sestavené entity, které se mají přidat do vaší aplikace,patří číslo , datetimeV2, geographyV2, ordinální.

Je důležité vědět, že entity nejsou označené záměrem. Mohou a obvykle platí pro mnoho záměrů. Pro konkrétní záměr jsou označené jenom příklady pro prosekcí uživatele.

Metody vytváření entit jsou součástí třídy Model. Každý typ entity má svůj vlastní model 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 entitami a funkcemi použitými na Quantity pod entity.

Částečný snímek obrazovky z portálu znázorňující vytvořenou entitu, entitu strojového učení s dílčími entitami a funkcemi použitými na pod entity Quantity 

// 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 třídy vyhledejte ID subentity Quantity, abyste mohli přiřadit funkce k této podentitě.

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í příkladu protterance do záměru

Aby bylo možné určit záměr protterance a extrahovat entity, potřebuje aplikace příklady prosemin. Příklady musí cílit na konkrétní záměr a měly by označovat všechny vlastní entity. Předem sestavené entity není potřeba označit.

Přidejte příklad projevy vytvořením seznamu objektů ExampleLabelObject , jeden objekt pro každý příklad utterance. Každý příklad by měl označit všechny entity pomocí slovníku dvojic název-hodnota a hodnota entity. Hodnota entity by měla být přesně tak, jak se zobrazuje v textu příkladu utterance.

Částečný snímek obrazovky ukazující vzorový utterance na portálu

Příklady volání. 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 musí být aplikace LUIS vyškolená pro tuto verzi modelu. Vyškolený model se dá použít v kontejnerunebo ho můžete publikovat na pracovní nebo výrobní sloty.

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

Velmi malý model, jako je například tento rychlý Start, bude vlak velmi rychlý. V případě aplikací na úrovni produkčního prostředí by mělo školení aplikace zahrnovat volání metody GetStatusAsync , které určuje, kdy nebo jestli bylo školení úspěšné. Odpověď je seznam objektů ModelTrainingInfo s odděleným stavem pro každý objekt. Aby bylo školení považovat 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;
    }
}

Publikovat aplikaci do produkčního slotu

Publikujte aplikaci LUIS pomocí metody PublishAsync . Tím se publikuje aktuální vyškolená verze v zadaném slotu na koncovém bodu. Klientská aplikace používá tento koncový bod k odeslání projevy uživatele pro předpověď záměru a extrakci entit.

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

Ověření běhového klienta předpovědi

Použijte objekt ApiKeyServiceClientCredentials s klíčem a použijte ho u svého koncového bodu k vytvoření objektu LUISRuntimeClient .

Upozornění

Tento rychlý Start používá jako součást přihlašovacích údajů za běhu klíč pro vytváření obsahu. Pro tento klíč je povolen dotaz na modul runtime s několika dotazy. V případě přípravného kódu a kódu na úrovni výroby nahraďte klíč pro vytváření předpověď klíč za běhu.

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

Získat předpovědi z modulu runtime

Přidejte následující kód, který vytvoří požadavek na modul runtime předpovědi.

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

Metoda GetSlotPredictionAsync potřebuje několik parametrů, jako je ID aplikace, název slotu nebo objekt požadavku předpovědi pro splnění požadavku. Ostatní 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));

Odezva 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í dotnet run příkazu z adresáře vaší aplikace.

dotnet run

K Node.js můžete použít klientské knihovny Language Understanding (LUIS):

  • Vytvoření aplikace
  • Přidejte záměr, počítačově získanou entitu s příkladem utterance
  • Výuka a publikování aplikace
  • Modul runtime předpovědi dotazů

Referenční dokumentace | Zdrojový kód knihovny pro vytváření a předpovědi | Vytváření a prediktivní npm | Ukázky

Požadavky

  • Node.js
  • Předplatné Azure – Vytvořte si ho zdarma .
  • Jakmile budete mít předplatné Azure, vytvořte v Azure Portal prostředek pro vytváření Language Understanding , abyste získali svůj klíč a koncový bod. Počkejte na nasazení a klikněte na tlačítko Přejít k prostředku .
    • Pro připojení aplikace k Language Understanding vytváření obsahu budete potřebovat klíč a koncový bod z prostředku, který vytvoříte . Svůj klíč a koncový bod vložíte do níže uvedeného kódu později v rychlém startu. Službu můžete vyzkoušet pomocí bezplatné cenové úrovně ( F0 ).

Nastavení

Vytvoření nové aplikace JavaScriptu

  1. V okně konzoly vytvořte nový adresář pro aplikaci a přesuňte se do tohoto adresáře.

    mkdir quickstart-sdk && cd quickstart-sdk

  2. Inicializujte adresář jako aplikaci JavaScriptu 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, které byly spuštěny vždy po jednom řádku:

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

Váš package.json vzhled by měl 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í Language Understanding (LUIS) je objekt LUISAuthoringClient , který se ověřuje v Azure, který obsahuje váš klíč pro vytváření obsahu.

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

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

Predikční objektový model

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

Příklady kódu pro modul runtime predikcí

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

Příklady kódu

Tyto fragmenty kódu ukazují, jak provést následující s klientskou knihovnou Language Understanding (LUIS) pro Python:

Přidání závislostí

Otevřete soubor index.js v upřednostňovaném editoru nebo integrovaném 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ých kódů

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

    const quickstart = async () => {

    // add calls here


}
quickstart()
    .then(result => console.log("Done"))
    .catch(err => {
        console.log(`Error: ${err}`)
        })

  2. Pokud není uvedeno jinak, přidejte zbývající kód v metodě rychlý Start.

Vytvoření proměnných pro aplikaci

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

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

    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 u svého koncového bodu 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 NLP (přirozený jazyk Processing), včetně záměrů, entit a příkladu projevy.

Vytvořte metodu Add objektu AppsOperation k vytvoření aplikace. Název a jazyková verze jazyka jsou požadované 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řit záměr pro aplikaci

Primárním objektem v modelu aplikace LUIS je záměr. Záměr se zarovnává se seskupením záměrů uživatelů utterance. Uživatel může požádat o dotaz nebo vytvořit příkaz, který hledá konkrétní zamýšlenou odpověď z robota (nebo jiné klientské aplikace). Příklady záměrů je vyúčtování letu, dotazování na počasí v cílovém městě a dotazování na kontaktní informace pro zákaznické služby.

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

intentNameHodnota je pevně zakódována OrderPizzaIntent jako součást proměnných v oddílu Vytvoření proměnných pro aplikaci .

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 protterance uživatele, které jsou nezbytné k úplnému vyhově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 objektů transformace dat (DTO). Mezi běžné předem sestavené entity, které se mají přidat do vaší aplikace,patří číslo , datetimeV2, geographyV2, ordinální.

Je důležité vědět, že entity nejsou označené záměrem. Mohou a obvykle platí pro mnoho záměrů. Pro konkrétní záměr jsou označené jenom příklady pro prosekcí uživatele.

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

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

Částečný snímek obrazovky z portálu znázorňující vytvořenou entitu, entitu strojového učení s dílčími entitami a funkcemi použitými na pod entity Quantity 

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

Dejte následující metodu nad metodu , abyste našli ID subentity Quantity, aby bylo možné přiřadit funkce k této quickstart podentitě.

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

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

}

Přidání příkladu protterance do záměru

Aby bylo možné určit záměr protterance a extrahovat entity, potřebuje aplikace příklady prosemin. Příklady musí cílit na konkrétní záměr a měly by označovat všechny vlastní entity. Předem sestavené entity není potřeba označit.

Přidejte příklady protterance vytvořením seznamu objektů ExampleLabelObject, jednoho objektu pro každou příkladovou protterance. Každý příklad by měl označit všechny entity slovníkem párů název/hodnota s názvem entity a hodnotou entity. Hodnota entity by měla být přesně tak, jak se zobrazuje v textu příkladu protterance.

Částečný snímek obrazovky zobrazující ukázku s popiskem protterance na portálu

Volejte 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 musí být aplikace LUIS vyškolená pro tuto verzi modelu. Vyškolený model se dá použít v kontejnerunebo ho můžete publikovat na pracovní nebo výrobní sloty.

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

Velmi malý model, jako je například tento rychlý Start, bude vlak velmi rychlý. Pro aplikace na úrovni produkčního prostředí by mělo školení aplikace zahrnovat volání metody get_Status k určení, kdy nebo jestli se školení podařilo. Odpověď je seznam objektů ModelTrainingInfo s odděleným stavem pro každý objekt. Aby bylo školení považovat 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;
    }
}

Publikovat aplikaci do produkčního slotu

Publikujte aplikaci LUIS pomocí metody App. Publish . Tím se publikuje aktuální vyškolená verze v zadaném slotu na koncovém bodu. Klientská aplikace používá tento koncový bod k odeslání projevy uživatele pro předpověď záměru a extrakci entit.

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

Ověření běhového klienta předpovědi

Použijte pro svůj klíč objekt msRest. ApiKeyCredentials a použijte ho u svého koncového bodu k vytvoření Luis. Objekt LUISRuntimeClient

Upozornění

Tento rychlý Start používá jako součást přihlašovacích údajů za běhu klíč pro vytváření obsahu. Pro tento klíč je povolen dotaz na modul runtime s několika dotazy. V případě přípravného kódu a kódu na úrovni výroby nahraďte klíč pro vytváření předpověď klíč za běhu.

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

Získat předpovědi z modulu runtime

Přidejte následující kód, který vytvoří požadavek na modul runtime předpovědi. Uživatel utterance je součástí objektu predictionRequest .

Metoda luisRuntimeClient. předpověď. getSlotPrediction potřebuje několik parametrů, jako je ID aplikace, název slotu a objekt žádosti o předpověď, který požadavek splní. Další možnosti jako verbose, Zobrazit všechny záměry 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 ));

Odezva 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í node index.js příkazu v souboru rychlého startu.

node index.js

Použijte klientské knihovny Language Understanding (LUIS) pro Python k těmto akcím:

  • Vytvoření aplikace
  • Přidejte záměr, počítačově získanou entitu s příkladem utterance
  • Výuka a publikování aplikace
  • Modul runtime předpovědi dotazů

Referenční dokumentace | Zdrojový kód knihovny pro vytváření a předpovědi | Balíček (PyPi) | Ukázky

Požadavky

  • Aktuální verze Pythonu 3. x.
  • Předplatné Azure – Vytvořte si ho zdarma .
  • Jakmile budete mít předplatné Azure, vytvořte v Azure Portal prostředek pro vytváření Language Understanding , abyste získali svůj klíč a koncový bod. Počkejte na nasazení a klikněte na tlačítko Přejít k prostředku .
    • Pro připojení aplikace k Language Understanding vytváření obsahu budete potřebovat klíč a koncový bod z prostředku, který vytvoříte . Svůj klíč a koncový bod vložíte do níže uvedeného kódu později v rychlém startu. Službu můžete vyzkoušet pomocí bezplatné cenové úrovně ( F0 ).

Nastavení

Vytvoření nové aplikace v Pythonu

  1. V okně konzoly vytvořte nový adresář pro aplikaci a přesuňte se do tohoto 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í PIP

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

pip install azure-cognitiveservices-language-luis

Vytváření objektového modelu

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

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

Po vytvoření klienta použijte tohoto klienta k přístupu k funkcím, včetně:

Predikční objektový model

Klient modulu runtime Language Understanding předpovědi (LUIS) je objekt LUISRuntimeClient, který se ověřuje v Azure a obsahuje váš klíč prostředku.

Příklady kódu pro modul runtime predikcí

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

Příklady kódu

Tyto fragmenty kódu ukazují, jak provést následující s klientskou knihovnou Language Understanding (LUIS) pro Python:

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ých kódů

  1. Přidejte quickstart metodu 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. Pokud neurčíte jinak, přidejte zbývající kód do metody quickstart.

Vytvoření proměnných pro aplikaci

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

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

    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 u svého koncového bodu k vytvoření objektu LUISAuthoringClient .

client = LUISAuthoringClient(authoringEndpoint, CognitiveServicesCredentials(authoringKey))

Vytvoření aplikace LUIS

Aplikace LUIS obsahuje model NLP (přirozený jazyk Processing), včetně záměrů, entit a příkladu projevy.

Vytvořte metodu Add objektu AppsOperation k vytvoření aplikace. Název a jazyková verze jazyka jsou požadované 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řit záměr pro aplikaci

Primárním objektem v modelu aplikace LUIS je záměr. Záměr se zarovnává se seskupením záměrů uživatelů utterance. Uživatel může požádat o dotaz nebo vytvořit příkaz, který hledá konkrétní zamýšlenou odpověď z robota (nebo jiné klientské aplikace). Příklady záměrů je vyúčtování letu, dotazování na počasí v cílovém městě a dotazování na kontaktní informace pro zákaznické služby.

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

intentNameHodnota je pevně zakódována OrderPizzaIntent jako součást proměnných v oddílu Vytvoření proměnných pro aplikaci .

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 utterance uživatele, která je nutná k zaúmyslnému záměru uživatele. Existuje několik typů předem sestavených a vlastních entit, z nichž každý má vlastní modely DTO (Data Transformation Object). Mezi běžné předem sestavené entity, které se mají přidat do vaší aplikace,patří číslo , datetimeV2, geographyV2, ordinální.

Je důležité vědět, že entity nejsou označené záměrem. Mohou a obvykle platí pro mnoho záměrů. Pro konkrétní záměr jsou označené jenom příklady pro prosekcí uživatele.

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

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

Částečný snímek obrazovky z portálu znázorňující vytvořenou entitu, entitu strojového učení s dílčími entitami a funkcemi použitými na pod entity Quantity 

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

Dejte následující metodu nad metodu , abyste našli ID subentity Quantity, aby bylo možné přiřadit funkce k této quickstart podentitě.

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í příkladu protterance do záměru

Aby bylo možné určit záměr protterance a extrahovat entity, potřebuje aplikace příklady prosemin. Příklady musí cílit na konkrétní záměr a měly by označovat všechny vlastní entity. Předem sestavené entity není potřeba označit.

Přidejte příklady protterance vytvořením seznamu objektů ExampleLabelObject, jednoho objektu pro každou příkladovou protterance. Každý příklad by měl označit všechny entity slovníkem párů název/hodnota s názvem entity a hodnotou entity. Hodnota entity by měla být přesně tak, jak se zobrazuje v textu příkladu protterance.

Částečný snímek obrazovky zobrazující ukázku s popiskem protterance na portálu

Volejte 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 vytrénovat aplikaci LUIS pro tuto verzi modelu. Natrénovaný model je možné použít v kontejnerunebo publikovat do pracovních nebo produktových slotů.

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

Velmi malý model, jako je například tento rychlý Start, bude vlak velmi rychlý. Pro aplikace na úrovni produkčního prostředí by mělo školení aplikace zahrnovat volání metody get_Status k určení, kdy nebo jestli se školení podařilo. Odpověď je seznam objektů ModelTrainingInfo s odděleným stavem pro každý objekt. Aby bylo školení považovat 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

Publikovat aplikaci do produkčního slotu

Publikujte aplikaci LUIS pomocí metody App. Publish . Tím se publikuje aktuální vyškolená verze v zadaném slotu na koncovém bodu. Klientská aplikace používá tento koncový bod k odeslání projevy uživatele pro předpověď záměru a extrakci 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í běhového klienta předpovědi

Použijte objekt přihlašovacích údajů pro svůj klíč a použijte ho u svého koncového bodu k vytvoření objektu LUISRuntimeClientConfiguration .

Upozornění

Tento rychlý Start používá jako součást přihlašovacích údajů za běhu klíč pro vytváření obsahu. Pro tento klíč je povolen dotaz na modul runtime s několika dotazy. V případě přípravného kódu a kódu na úrovni výroby nahraďte klíč pro vytváření předpověď klíč za běhu.

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

Získat předpovědi z modulu runtime

Přidejte následující kód, který vytvoří požadavek na modul runtime předpovědi.

Uživatel utterance je součástí objektu prediction_request .

Metoda get_slot_prediction potřebuje několik parametrů, jako je ID aplikace, název slotu a objekt žádosti o předpověď splnění žádosti. Další možnosti jako verbose, Zobrazit všechny záměry 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))

Odezva 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í python příkazu v souboru rychlého startu.

python authoring_and_predict.py

Podle tohoto rychlého startu budete provádět tři volání REST v pořadí.

  • Nejdřív nahrajete dávku ukázkového projevy, který se bude používat ke školení modelu aplikace Pizza, pomocí volání metody Add Labels v dávce .
  • V dalším kroku zahájíte výukovou relaci pro aplikaci Pizza, a to pomocí volání rozhraní REST pro použití verze .
  • Nakonec obdržíte stav výukové relace pro aplikaci Pizza s použitím volání stavu služby Get Version Train .

Referenční dokumentace

Předpoklady

  • Bezplatný účet Luis .

  • Textový editor, jako je například Visual Studio Code.

  • Program příkazového řádku kudrlinkou. Oblý program je už nainstalovaný v macOS, většinu distribucí pro Linux a Windows 10 Build 1803 a novější.

    Je-li nutné nainstalovat soubor kudrlinkou, můžete ze stránky pro stažení ze složenéaplikace Stáhnout soubor.

Vytvoření aplikace Pizza

Vytvořte aplikaci Pizza.

  1. Vyberte možnost pizza-app-for-luis-v6.jszapnuto a zobrazte stránku GitHub pro daný pizza-app-for-luis.json soubor.
  2. Klikněte pravým tlačítkem nebo dlouho klepněte na tlačítko nezpracované a vyberte Uložit odkaz jako a uložte pizza-app-for-luis.json ho do svého 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 Vybrat soubor .
  8. Vyberte pizza-app-for-luis.json soubor, který jste stáhli, a pak vyberte otevřít.
  9. V poli název dialogového okna importovat novou aplikaci zadejte název vaší 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.

Výuka a publikování aplikace 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 výuka .

    Tlačítko Train (Trénovat)

  2. Školení je hotové, když je indikátor stavu na tlačítku vlaku zelený.

Aby bylo možné získat LUIS předpověď v robotu chatu nebo v jiné klientské aplikaci, musíte aplikaci publikovat do koncového bodu předpovědi.

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

    Snímek obrazovky s tlačítkem publikovat do koncového bodu LUIS v pravé horní nabídce

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

    Snímek obrazovky s LUIS publikováním do koncového bodu

  3. V oznámení vyberte přístup k adresám URL koncových bodů . tím přejdete na stránku prostředků Azure . Adresy URL budete moct zobrazit jenom v případě, že máte k aplikaci přidružený prostředek předpovědi. Stránku prostředků Azure můžete také najít kliknutím na Spravovat.

    Zpráva o tom, že byla aplikace publikována

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

  1. Vyberte Spravovat.
  2. Vyberte Azure Resources (Prostředky Azure).
  3. Vyberte prostředek 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 prostředku pro vytváření obsahu.

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í.

Poznamenejte si hodnoty pro přístup k aplikaci Pizza.

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

Vyhledání těchto hodnot:

  1. Na stránce záměry vyberte Spravovat.
  2. Na stránce nastavení aplikace si poznamenejte ID aplikace.
  3. Vyberte Azure Resources (Prostředky Azure).
  4. Vyberte prostředek pro vytváření obsahu.
  5. Na kartách prostředky pro vytváření prostředků a předpovědí prostředků zaznamenejte primární klíč. Tato hodnota je váš kód pro vytváření.
  6. Zaznamenejte adresu URL koncového bodu. Tato hodnota je vaším koncovým bodem pro vytváření obsahu.

Vytvoření souboru JSON pro výuku aplikace Pizza

Chcete-li vytvořit soubor JSON se třemi vzorovými projevy, 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
      }
    ]
  }
]`

Vzorový projevy JSON sleduje konkrétní formát.

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 je popisek začínat nebo končit v prostoru v textu, volání rozhraní API pro přidání projevy se nezdařilo.

Přidat ukázkové promluvy

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

    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í _*_YOUR- vlastními hodnotami.

    Informace Účel
    _*_YOUR-AUTHORING-ENDPOINT_*_ Váš koncový bod adresy URL pro vytváření Například https://REPLACE-WITH-YOUR-RESOURCE-NAME.api.cognitive.microsoft.com/. Název prostředku se nastaví při vytváření prostředku.
    _*_YOUR-APP-ID_*_ Vaše ID aplikace LUIS
    _*_YOUR-APP-VERSION_*_ Verze aplikace LUIS V případě aplikace Pizza je číslo verze "0,1" bez uvozovek.
    _*_YOUR-AUTHORING-KEY_*_ Klíč pro vytváření znaků 32.

    Přiřazené klíče a prostředky se zobrazí na portálu LUIS v části Správa na stránce _ Azure prostředků*. ID aplikace je k dispozici ve stejné části pro správu na stránce nastavení aplikace .

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

  4. Z editoru zkopírujte příkaz kudrlinkou a vložte ho do příkazového řádku (Windows) nebo terminálu (macOS a Linux). Stiskněte klávesu ENTER a 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
  }
]

Výuka modelu aplikace Pizza

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

    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 dříve nahraďte hodnoty začínající _*_YOUR- vlastními hodnotami.

  3. Z editoru zkopírujte příkaz kudrlinkou a vložte ho do příkazového řádku (Windows) nebo terminálu (macOS a Linux). Stiskněte klávesu ENTER a 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 školení

  1. Chcete-li získat stav školení pro cvičení cvičení, zkopírujte tento příkaz do textového editoru:

    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 dříve nahraďte hodnoty začínající _*_YOUR- vlastními hodnotami.

  3. Z editoru zkopírujte příkaz kudrlinkou a vložte ho do příkazového řádku (Windows) nebo terminálu (macOS a Linux). Stiskněte klávesu ENTER a 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ískat záměr z koncového bodu předpovědi

Použijte kudrlinkou k dotazování koncového bodu předpovědi a získejte výsledek předpovědi.

Poznámka

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

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

    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í _*_YOUR- vlastními hodnotami.

    Informace Účel
    _*_YOUR-PREDICTION-ENDPOINT_*_ Koncový bod adresy URL předpovědi Nachází se na portálu LUIS, stránce prostředků Azure pro vaši aplikaci.
    Například, https://westus.api.cognitive.microsoft.com/.
    _*_YOUR-APP-ID_*_ Vaše ID aplikace Nachází se na portálu LUIS, na stránce nastavení aplikace pro vaši aplikaci.
    _*_YOUR-PREDICTION-KEY_** Klíč předpovědi znaků 32. Nachází se na portálu LUIS, stránce prostředků 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ěď předpovědi, 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 formá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 prostředky Azure z webu Azure Portal.

Pokud používáte tento REST API, odstraňte soubor ze systému souborů, jakmile budete s tímto rychlým startem ExampleUtterances.JSON hotovi.

Řešení potíží

  • Ověřování v klientské knihovně – chyby ověřování obvykle značí, že se & koncový bod použil nesprávný klíč. V tomto rychlém startu se pro usnadnění používá klíč a koncový bod pro vytváření pro modul runtime predikcí, ale bude fungovat pouze v případě, že jste ještě nevyužít měsíční kvótu. Pokud nemůžete použít klíč a koncový bod pro vytváření obsahu, musíte při přístupu ke klientské knihovně sady SDK pro predikce použít klíč a koncový bod modulu runtime predikce.
  • 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 zkopíroval kód a neměníte kód tak, aby se vytvořila jiná entita.
  • Vytváření příkladů protterance – pokud se zobrazí chyba při vytváření označené příkladové protterance použité v tomto kurzu, ujistěte se, že jste zkopíroval kód a neměníte kód tak, aby se vytvořil jiný příklad s popiskem.
  • Trénování – pokud se zobrazí chyba trénování, obvykle to značí prázdnou aplikaci (bez záměrů s příklady prosek) nebo aplikaci se záměry nebo entitami, které jsou poškozené.
  • Různé chyby – protože kód volá do klientských knihoven s textem a objekty JSON, ujistěte se, že jste kód nezměnili.

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

Další kroky

Iterativní vývoj aplikací pro LUIS