Avvio rapido: Librerie client e API REST di Language Understanding (LUIS)

Articolo
11/06/2024

Importante

LUIS verrà ritirato il 1 ottobre 2025 e a partire dal 1 aprile 2023 non è più possibile creare nuove risorse LUIS. È consigliabile eseguire la migrazione delle applicazioni LUIS a comprensione del linguaggio di conversazione (CLU) per trarre vantaggio dal supporto continuo del prodotto e dalle funzionalità multilingua.

Guida di avvio rapido su come creare ed eseguire query su un'app di intelligenza artificiale (IA) di Azure LUIS con le librerie client di LUIS SDK con C#, Python o JavaScript. È anche possibile usare cURL per inviare richieste con l'API REST.

Language Understanding (LUIS) consente di applicare l'elaborazione del linguaggio naturale (NLP, Natural Language Processing) al testo in linguaggio naturale della conversazione di un utente per prevedere il significato generale ed estrarre informazioni pertinenti e dettagliate.

La libreria client e l'API REST di creazione consentono di creare, modificare, eseguire il training e pubblicare l'app LUIS.
La libreria client e l'API REST del runtime di previsione consentono di eseguire query sull'app pubblicata.

Usare le librerie client di LUIS (Language Understanding) per .NET per:

Crea un'app
Aggiungere una finalità, un'entità basata Machine Learning, con un'espressione di esempio
Eseguire il training e pubblicare l'app
Eseguire query sul runtime di previsione

Documentazione di riferimento | Codice sorgente della libreria di creazione e previsione | NuGet di creazione e previsione | Esempio in C#

Prerequisiti

La versione corrente di .NET Core e dell'interfaccia della riga di comando di .NET Core.
Sottoscrizione di Azure: creare un account gratuito
Dopo aver creato la sottoscrizione di Azure, creare una risorsa di creazione Language Understanding nel portale di Azure per ottenere la chiave e l'endpoint. Attendere che venga distribuita e fare clic sul pulsante Vai alla risorsa.
- La chiave e l'endpoint della risorsa creata sono necessari per connettere l'applicazione alla creazione di Language Understanding. La chiave e l'endpoint verranno incollati nel codice riportato di seguito nell'argomento di avvio rapido. Per provare il servizio, è possibile usare il piano tariffario gratuito (F0).

Configurazione

Creare una nuova applicazione C#

Creare una nuova applicazione .NET Core nell'ambiente di sviluppo integrato o nell'editor preferito.

Nella finestra di una console (ad esempio cmd, PowerShell o Bash) usare il comando dotnet new per creare una nuova app console con il nome language-understanding-quickstart. Questo comando crea un semplice progetto C# "Hello World" con un singolo file di origine: Program.cs.
```
dotnet new console -n language-understanding-quickstart
```
Spostarsi nella cartella dell'app appena creata.
```
cd language-understanding-quickstart
```
È possibile compilare l'applicazione con il comando seguente:
```
dotnet build
```
L'output di compilazione non deve contenere alcun avviso o errore.
```
...
Build succeeded.
 0 Warning(s)
 0 Error(s)
...
```

Installare le librerie NuGet

Nella directory dell'applicazione installare le librerie client di LUIS (Language Understanding) per .NET con i comandi seguenti:

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

Modello a oggetti di creazione

Il client di creazione di Language Understanding (LUIS) è un oggetto LUISAuthoringClient contenente la chiave di creazione che esegue l'autenticazione in Azure.

Esempi di codice per la creazione

Al termine della creazione del client, usare il client per accedere alle funzionalità, tra cui:

App: creazione, eliminazione, pubblicazione
Espressioni di esempio: aggiunta, eliminazione in base a ID
Funzionalità: gestione di elenchi di frasi
Modello: gestione di finalità ed entità
Criterio: gestione di criteri
Training: training dell'app e polling per lo stato del training
Versioni: gestione con clonazione, esportazione ed eliminazione

Modello a oggetti di previsione

Il client del runtime di previsioni di LUIS (Language Understanding) è un oggetto LUISRuntimeClient che esegue l'autenticazione in Azure e contiene la chiave della risorsa.

Esempi di codice per il runtime di previsione

Al termine della creazione del client, usare il client per accedere alle funzionalità, tra cui:

Previsioni per slot di staging o produzione
Previsioni per versione

Esempi di codice

Questi frammenti di codice mostrano come eseguire le operazioni seguenti con la libreria client di LUIS (Language Understanding) per Python:

Creare un'app
Aggiungere finalità
Aggiungere entità
Aggiungi espressioni di esempio
Eseguire il training dell'app
Pubblicare l'app
Previsioni per slot

Aggiungere le dipendenze

Dalla directory del progetto aprire il file Program.cs nell'ambiente di sviluppo integrato o nell'editor preferito. Sostituire il codice using esistente con le direttive using seguenti:

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;

Aggiungere il codice boilerplate

Cambiare la firma del metodo Main per consentire chiamate asincrone:
```
public static async Task Main()
```
Aggiungere il resto del codice nel metodo Main della classe Program se non diversamente specificato.

Creare variabili per l'app

Creare due set di variabili: il primo set modificato, il secondo set viene lasciato come visualizzato nell'esempio di codice.

Importante

Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per un ambiente di produzione usare un metodo sicuro per l'archiviazione e l'accesso alle proprie credenziali, ad esempio Azure Key Vault. Per altre informazioni, vedere l'articolo sulla sicurezza del Servizi di Azure AI.

Creare le variabili in cui contenere la chiave di creazione e i nomi delle risorse.

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

Creare le variabili in cui contenere gli endpoint, il nome dell'app, la versione e il nome della finalità.
```
var appName = "Contoso Pizza Company";
var versionId = "0.1";
var intentName = "OrderPizzaIntent";
```

Autenticare il client

Creare un oggetto ApiKeyServiceClientCredentials con la chiave e usarlo con l'endpoint per creare un oggetto LUISAuthoringClient.

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

Creare un'app LUIS

Un'app LUIS contiene il modello di elaborazione del linguaggio naturale (NLP) che include finalità, entità ed espressioni di esempio.

Creare un oggetto ApplicationCreateObject. Il nome e le impostazioni cultura della lingua sono proprietà obbligatorie. Chiamare il metodo Apps.AddAsync. La risposta corrisponde all'ID app.

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

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

Creare la finalità per l'app

L'oggetto primario in un modello di app LUIS è la finalità. La finalità è allineata a un raggruppamento di intenzioni delle espressioni dell'utente. Un utente può porre una domanda o fare un'affermazione per una risposta con finalità specifica da un bot o da un'altra applicazione client. Alcuni esempi di intenzioni sono la prenotazione di un volo, la richiesta di informazioni meteo per una città di destinazione e la richiesta di informazioni di contatto per il servizio clienti.

Creare un oggetto ModelCreateObject con il nome della finalità univoca, quindi passare l'ID app, l'ID versione e l'oggetto ModelCreateObject al metodo Model.AddIntentAsync. La risposta corrisponde all'ID finalità.

Il valore intentName è hardcoded per OrderPizzaIntent come parte delle variabili descritte nella sezione Creare variabili per l'app.

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

Creare le entità per l'app

Sebbene le entità non siano obbligatorie, sono in genere presenti nella maggior parte delle app. L'entità estrae le informazioni necessarie per soddisfare l'intenzione dell'utente dall'espressione dell'utente. Sono disponibili numerosi tipi di entità predefinite e personalizzate, ognuna con i propri modelli DTO (Data Transformation Object). Le entità predefinite comuni da aggiungere all'app includono number, datetimeV2, geographyV2, ordinal.

È importante tenere presente che le entità non sono contrassegnate con una finalità. Possono in genere essere applicate a molte finalità. Solo le espressioni utente di esempio sono contrassegnate per una singola finalità specifica.

I metodi di creazione per le entità sono parte della classe Model. Ogni tipo di entità dispone di un modello DTO (Data Transformation Object) specifico, in genere contenente la parola model nello spazio dei nomi Models.

Il codice di creazione entità crea un'entità basata su Machine Learning con le sottoentità e le funzionalità applicate alle sottoentità Quantity.

Screenshot parziale del portale che mostra l'entità creata, un'entità di Machine Learning con le sottoentità e le funzionalità applicate alle sottoentità '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" });

Usare il metodo seguente per la classe per individuare l'ID della sottoentità Quantity, in modo da assegnare le funzionalità a tale sottoentità.

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

Aggiungere un'espressione di esempio alla finalità

Per determinare l'intenzione di un'espressione ed estrarre le entità, l'app necessita di esempi di espressioni. Gli esempi devono fare riferimento a un'unica finalità specifica e contrassegnare tutte le entità personalizzate. Non è necessario contrassegnare le entità predefinite.

Aggiungere le espressioni di esempio creando un elenco di oggetti ExampleLabelObject, un oggetto per ogni espressione di esempio. Ogni esempio deve contrassegnare tutte le entità con un dizionario di coppie nome/valore con nome dell'entità e valore dell'entità. Il valore dell'entità deve corrispondere esattamente a quanto visualizzato nel testo dell'espressione di esempio.

Screenshot parziale che mostra l'espressione di esempio etichettata nel portale.

Chiamare Examples.AddAsync con l'ID app, l'ID versione e l'esempio.

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

Eseguire il training dell'app

Dopo aver creato il modello, è necessario eseguire il training dell'app LUIS per questa versione del modello. Un modello sottoposto a training può essere usatoin un contenitore o pubblicato negli slot di staging o di produzione.

Il metodo Train.TrainVersionAsync richiede l'ID app e l'ID versione.

Il training di un modello di dimensioni ridotte, come quello mostrato in questa esercitazione di avvio rapido, verrà eseguito molto rapidamente. Per le applicazioni a livello di produzione, il training dell'app deve includere una chiamata di polling al metodo GetStatusAsync per determinare quando o se il training ha avuto esito positivo. La risposta è un elenco di oggetti ModelTrainingInfo con uno stato separato per ogni oggetto. Affinché il training venga considerato completato, è necessario che tutti gli oggetti abbiano esito positivo.

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

Pubblicare l'app nello slot di produzione

Pubblicare l'app LUIS con il metodo PublishAsync. Questo metodo consente di pubblicare la versione con training corrente nello slot specificato nell'endpoint. L'applicazione client usa questo endpoint per inviare espressioni utente per la previsione della finalità e l'estrazione di entità.

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

Autenticare il client del runtime di previsione

Usare un oggetto ApiKeyServiceClientCredentials con la chiave e con l'endpoint per creare un oggetto LUISRuntimeClient.

Attenzione

Questo argomento di avvio rapido usa la chiave di creazione come parte delle credenziali del runtime. La chiave di creazione è autorizzata a eseguire alcune query sul runtime. Per il codice di staging e a livello di produzione, sostituire la chiave di creazione con una chiave del runtime di previsione.

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

Ottenere previsioni dal runtime

Aggiungere il codice seguente per creare la richiesta al runtime di previsione.

L'espressione utente fa parte dell'oggetto PredictionRequest.

Per soddisfare la richiesta, il metodo GetSlotPredictionAsync richiede diversi parametri, ad esempio l'ID app, il nome dello slot e l'oggetto richiesta di previsioni. Le altre opzioni, ad esempio per l'output dettagliato, la visualizzazione di tutte le finalità e il log, sono facoltative.

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

La risposta di previsione è un oggetto JSON che include la finalità e le entità trovate.

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

Eseguire l'applicazione

Eseguire l'applicazione con il comando dotnet run dalla directory dell'applicazione.

dotnet run

Usare le librerie client di LUIS (Language Understanding) per Node.js per:

Crea un'app
Aggiungere una finalità, un'entità basata Machine Learning, con un'espressione di esempio
Eseguire il training e pubblicare l'app
Eseguire query sul runtime di previsione

Documentazione di riferimento | Creazione e Previsione NPM | Esempi

Prerequisiti

Node.JS
Sottoscrizione di Azure: creare un account gratuito
Dopo aver creato la sottoscrizione di Azure, creare una risorsa di creazione Language Understanding nel portale di Azure per ottenere la chiave e l'endpoint. Attendere che venga distribuita e fare clic sul pulsante Vai alla risorsa.
- La chiave e l'endpoint della risorsa creata sono necessari per connettere l'applicazione alla creazione di Language Understanding. La chiave e l'endpoint verranno incollati nel codice riportato di seguito nell'argomento di avvio rapido. Per provare il servizio, è possibile usare il piano tariffario gratuito (F0).

Configurazione

Creare una nuova applicazione JavaScript

In una finestra della console creare una nuova directory per l'applicazione e accedervi.
```
mkdir quickstart-sdk && cd quickstart-sdk
```
Inizializzare la directory come applicazione JavaScript creando un file package.json.
```
npm init -y
```
Creare un file denominato index.js per il codice JavaScript.
```
touch index.js
```

Installare le librerie NPM

Nella directory dell'applicazione installare le dipendenze con i comandi seguenti, eseguiti una riga alla volta:

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

package.json dovrebbe essere simile al seguente:

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

Modello a oggetti di creazione

Il client di creazione di Language Understanding (LUIS) è un oggetto LUISAuthoringClient contenente la chiave di creazione che esegue l'autenticazione in Azure.

Esempi di codice per la creazione

Al termine della creazione del client, usare il client per accedere alle funzionalità, tra cui:

Apps: aggiungi, elimina, pubblica
Espressioni di esempio: aggiunta in base al batch, eliminazione in base all'ID
Funzionalità: gestione di elenchi di frasi
Modello: gestione di finalità ed entità
Criterio: gestione di criteri
Training: training dell'app e polling per lo stato del training
Versioni: gestione con clonazione, esportazione ed eliminazione

Modello a oggetti di previsione

Il client di creazione di Language Understanding (LUIS) è un oggetto LUISAuthoringClient contenente la chiave di creazione che esegue l'autenticazione in Azure.

Esempi di codice per il runtime di previsione

Al termine della creazione del client, usare il client per accedere alle funzionalità, tra cui:

Previsioni per slot di staging o production
Previsioni per versione

Esempi di codice

Questi frammenti di codice mostrano come eseguire le operazioni seguenti con la libreria client di LUIS (Language Understanding) per Python:

Creare un'app
Aggiungere finalità
Aggiungere entità
Aggiungi espressioni di esempio
Eseguire il training dell'app
Pubblicare l'app
Previsioni per slot

Aggiungere le dipendenze

Aprire il file index.js nell'editor o nell'IDE preferito, quindi aggiungere le dipendenze seguenti.

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

Aggiungere il codice boilerplate

Aggiungere il metodo quickstart e la relativa chiamata. Questo metodo include la maggior parte del codice rimanente. Questo metodo viene chiamato alla fine del file.

const quickstart = async () => {

    // add calls here


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

Aggiungere il codice rimanente nel metodo di avvio rapido se non diversamente specificato.

Creare variabili per l'app

Creare due set di variabili: il primo set modificato, il secondo set viene lasciato come visualizzato nell'esempio di codice.

Importante

Creare le variabili in cui contenere la chiave di creazione e i nomi delle risorse.

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

Creare le variabili in cui contenere gli endpoint, il nome dell'app, la versione e il nome della finalità.
```
const appName = "Contoso Pizza Company";
const versionId = "0.1";
const intentName = "OrderPizzaIntent";
```

Autenticare il client

Creare un oggetto CognitiveServicesCredentials con la chiave e usarlo con l'endpoint per creare un oggetto LUISAuthoringClient.

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

Creare un'app LUIS

Un'app LUIS contiene il modello di elaborazione del linguaggio naturale (NLP) che include finalità, entità ed espressioni di esempio.

Create il metodo add di un oggetto AppsOperation per creare l'app. Il nome e le impostazioni cultura della lingua sono proprietà obbligatorie.

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

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

const appId = createAppResult.body

Creare la finalità per l'app

Usare il metodo model.add_intent con il nome della finalità univoca e quindi passare l'ID app, l'ID versione e il nuovo nome della finalità.

Il valore intentName è hardcoded per OrderPizzaIntent come parte delle variabili descritte nella sezione Creare variabili per l'app.

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

Creare le entità per l'app

I metodi di creazione per le entità sono parte della classe Model. Ogni tipo di entità ha il proprio modello DTO (Data Transformation Object).

Il codice di creazione entità crea un'entità basata su Machine Learning con le sottoentità e le funzionalità applicate alle sottoentità Quantity.

Screenshot parziale del portale che mostra l'entità creata, un'entità di Machine Learning con le sottoentità e le funzionalità applicate alle sottoentità '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" });

Posizionare il metodo seguente sopra il metodo quickstart per individuare l'ID della sottoentità Quantity, in modo da assegnare le funzionalità a tale sottoentità.

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

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

}

Aggiungere un'espressione di esempio alla finalità

Screenshot parziale che mostra l'espressione di esempio etichettata nel portale.

Chiamare examples.add con l'ID app, l'ID versione e l'esempio.

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

Eseguire il training dell'app

Il metodo train.trainVersion richiede l'ID app e l'ID versione.

Il training di un modello di dimensioni ridotte, come quello mostrato in questa esercitazione di avvio rapido, verrà eseguito molto rapidamente. Per le applicazioni a livello di produzione, il training dell'app deve includere una chiamata di polling al metodo get_status per determinare quando o se il training è riuscito. La risposta è un elenco di oggetti ModelTrainingInfo con uno stato separato per ogni oggetto. Affinché il training venga considerato completato, è necessario che tutti gli oggetti abbiano esito positivo.

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

Pubblicare l'app nello slot di produzione

Pubblicare l'app LUIS tramite il metodo app.publish. Questo metodo consente di pubblicare la versione con training corrente nello slot specificato nell'endpoint. L'applicazione client usa questo endpoint per inviare espressioni utente per la previsione della finalità e l'estrazione di entità.

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

Autenticare il client del runtime di previsione

Usare un oggetto msRest.ApiKeyCredentials con la chiave e con l'endpoint per creare un oggetto LUIS.LUISRuntimeClient.

Attenzione

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

Ottenere previsioni dal runtime

Aggiungere il codice seguente per creare la richiesta al runtime di previsione. L'espressione utente fa parte dell'oggetto predictionRequest.

Per soddisfare la richiesta, il metodo luisRuntimeClient.prediction.getSlotPrediction richiede numerosi parametri, ad esempio l'ID app, il nome dello slot e l'oggetto richiesta di previsioni. Le altre opzioni, ad esempio per l'output dettagliato, la visualizzazione di tutte le finalità e il log, sono facoltative.

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

La risposta di previsione è un oggetto JSON che include la finalità e le entità trovate.

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

Eseguire l'applicazione

Eseguire l'applicazione con il comando node index.js nel file quickstart.

node index.js

Usare le librerie client di LUIS (Language Understanding) per Python per:

Crea un'app
Aggiungere una finalità, un'entità basata Machine Learning, con un'espressione di esempio
Eseguire il training e pubblicare l'app
Eseguire query sul runtime di previsione

Documentazione di riferimento | Codice sorgente della libreria di creazione e previsione | Pacchetto (Pypi) | Esempi

Prerequisiti

La versione corrente di Python 3.x.
Sottoscrizione di Azure: creare un account gratuito
Dopo aver creato la sottoscrizione di Azure, creare una risorsa di creazione Language Understanding nel portale di Azure per ottenere la chiave e l'endpoint. Attendere che venga distribuita e fare clic sul pulsante Vai alla risorsa.
- La chiave e l'endpoint della risorsa creata sono necessari per connettere l'applicazione alla creazione di Language Understanding. La chiave e l'endpoint verranno incollati nel codice riportato di seguito nell'argomento di avvio rapido. Per provare il servizio, è possibile usare il piano tariffario gratuito (F0).

Configurazione

Creare una nuova applicazione Python

In una finestra della console creare una nuova directory per l'applicazione e accedervi.
```
mkdir quickstart-sdk && cd quickstart-sdk
```
Creare un file denominato authoring_and_predict.py per il codice Python.
```
touch authoring_and_predict.py
```

È possibile installare la libreria client con Pip

Nella directory dell'applicazione installare la libreria client di LUIS (Language Understanding) per Python con il comando seguente:

pip install azure-cognitiveservices-language-luis

Modello a oggetti di creazione

Il client di creazione di Language Understanding (LUIS) è un oggetto LUISAuthoringClient contenente la chiave di creazione che esegue l'autenticazione in Azure.

Esempi di codice per la creazione

Al termine della creazione del client, usare il client per accedere alle funzionalità, tra cui:

App: creazione, eliminazione, pubblicazione
Espressioni di esempio: aggiunta in base al batch, eliminazione in base all'ID
Funzionalità: gestione di elenchi di frasi
Modello: gestione di finalità ed entità
Criterio: gestione di criteri
Training: training dell'app e polling per lo stato del training
Versioni: gestione con clonazione, esportazione ed eliminazione

Modello a oggetti di previsione

Il client del runtime di previsioni di LUIS (Language Understanding) è un oggetto LUISRuntimeClient che esegue l'autenticazione in Azure e contiene la chiave della risorsa.

Esempi di codice per il runtime di previsione

Al termine della creazione del client, usare il client per accedere alle funzionalità, tra cui:

Previsioni per slot di staging o produzione
Previsioni per versione

Esempi di codice

Questi frammenti di codice mostrano come eseguire le operazioni seguenti con la libreria client di LUIS (Language Understanding) per Python:

Creare un'app
Aggiungere finalità
Aggiungere entità
Aggiungi espressioni di esempio
Eseguire il training dell'app
Pubblicare l'app
Previsioni per slot

Aggiungere le dipendenze

Aggiungere le librerie client al file Python.

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

import json, time, uuid

Aggiungere il codice boilerplate

Aggiungere il metodo quickstart e la relativa chiamata. Questo metodo include la maggior parte del codice rimanente. Questo metodo viene chiamato alla fine del file.
```
def quickstart():

    # add calls here, remember to indent properly

quickstart()
```
Aggiungere il codice rimanente nel metodo di avvio rapido se non diversamente specificato.

Creare variabili per l'app

Creare due set di variabili: il primo set modificato, il secondo set viene lasciato come visualizzato nell'esempio di codice.

Importante

Creare le variabili in cui contenere la chiave di creazione e i nomi delle risorse.

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'

Creare le variabili in cui contenere gli endpoint, il nome dell'app, la versione e il nome della finalità.

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

Autenticare il client

Creare un oggetto CognitiveServicesCredentials con la chiave e usarlo con l'endpoint per creare un oggetto LUISAuthoringClient.

client = LUISAuthoringClient(authoringEndpoint, CognitiveServicesCredentials(authoringKey))

Creare un'app LUIS

Un'app LUIS contiene il modello di elaborazione del linguaggio naturale (NLP) che include finalità, entità ed espressioni di esempio.

Create il metodo add di un oggetto AppsOperation per creare l'app. Il nome e le impostazioni cultura della lingua sono proprietà obbligatorie.

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

Creare la finalità per l'app

Usare il metodo model.add_intent con il nome della finalità univoca e quindi passare l'ID app, l'ID versione e il nuovo nome della finalità.

Il valore intentName è hardcoded per OrderPizzaIntent come parte delle variabili descritte nella sezione Creare variabili per l'app.

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

Creare le entità per l'app

I metodi di creazione per le entità fanno parte della classe ModelOperations. Ogni tipo di entità ha il proprio modello DTO (Data Transformation Object).

Il codice di creazione entità crea un'entità basata su Machine Learning con le sottoentità e le funzionalità applicate alle sottoentità Quantity.

Screenshot parziale del portale che mostra l'entità creata, un'entità di Machine Learning con le sottoentità e le funzionalità applicate alle sottoentità '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)

Posizionare il metodo seguente sopra il metodo quickstart per individuare l'ID della sottoentità Quantity, in modo da assegnare le funzionalità a tale sottoentità.

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

Aggiungere un'espressione di esempio alla finalità

Screenshot parziale che mostra l'espressione di esempio etichettata nel portale.

Chiamare examples.add con l'ID app, l'ID versione e l'esempio.

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

Eseguire il training dell'app

Il metodo train.train_version richiede l'ID app e l'ID versione.

Il training di un modello di dimensioni ridotte, come quello mostrato in questa esercitazione di avvio rapido, verrà eseguito molto rapidamente. Per le applicazioni a livello di produzione, il training dell'app deve includere una chiamata di polling al metodo get_status per determinare quando o se il training è riuscito. La risposta è un elenco di oggetti ModelTrainingInfo con uno stato separato per ogni oggetto. Affinché il training venga considerato completato, è necessario che tutti gli oggetti abbiano esito positivo.

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

Pubblicare l'app nello slot di produzione

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

Autenticare il client del runtime di previsione

Usare l'oggetto credenziali con la chiave e con l'endpoint per creare un oggetto LUISRuntimeClientConfiguration.

Attenzione

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

Ottenere previsioni dal runtime

Aggiungere il codice seguente per creare la richiesta al runtime di previsione.

L'espressione utente fa parte dell'oggetto prediction_request.

Per soddisfare la richiesta, il metodo get_slot_prediction richiede numerosi parametri, ad esempio l'ID app, il nome dello slot e l'oggetto richiesta di previsioni. Le altre opzioni, ad esempio per l'output dettagliato, la visualizzazione di tutte le finalità e il log, sono facoltative. La richiesta restituisce un oggetto 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))

La risposta di previsione è un oggetto JSON che include la finalità e le entità trovate.

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

Eseguire l'applicazione

Eseguire l'applicazione con il comando python nel file quickstart.

python authoring_and_predict.py

Seguendo questo argomento di avvio rapido, si eseguiranno tre chiamate REST in sequenza.

Prima di tutto si caricherà un batch di espressioni di esempio, che verranno usate per eseguire il training del modello di app Pizza, usando la chiamata REST Batch add labels.
Verrà quindi avviata una sessione di training per l'app Pizza usando la chiamata REST Train application version.
Infine, si otterrà lo stato della sessione di training per l'app Pizza usando la chiamata REST Get version training status.

Documentazione di riferimento

Prerequisiti

Un account LUIS gratuito.
Un editor di testo, ad esempio Visual Studio Code.
Il programma da riga di comando cURL. Il programma cURL è già installato in macOS, nella maggior parte delle distribuzioni Linux e in Windows 10 build 1803 e versioni successive.

Se è necessario installare cURL, è possibile scaricarlo dalla pagina di download di cURL.

Creare l’app Pizza

Creare l'app Pizza.

Selezionare pizza-app-for-luis-v6.json per aprire la pagina di GitHub per il file pizza-app-for-luis.json.
Toccare e tenere premuto a lungo o fare clic con il pulsante destro del mouse sul pulsante Raw e selezionare Salva collegamento come per salvare pizza-app-for-luis.json nel computer.
Accedere al portale LUIS.
Selezionare App personali.
Nella pagina App personali, selezionare + Nuova app di conversazione.
Selezionare Importa come JSON.
Nella finestra di dialogo Importa nuova app selezionare il pulsante Scegli file.
Selezionare il file pizza-app-for-luis.json scaricato e quindi selezionare Apri.
Nel campo Nome della finestra di dialogo Importa nuova app immettere un nome per l'app Pizza, quindi selezionare il pulsante Fatto.

L'app verrà importata.

Se viene visualizzata una finestra di dialogo Come creare un'app di LUIS efficace, chiudere la finestra di dialogo.

Eseguire il training dell’app Pizza e pubblicarla

Verrà visualizzata la pagina Finalità con un elenco delle finalità dell'app pizza.

In alto a destra nel sito Web LUIS selezionare il pulsante Train (Esegui il training).
Il training è completo quando il pulsante Esegui training risulta disabilitato.

Per ottenere una previsione LUIS in un chatbot o in un'altra applicazione client, è necessario pubblicare l'app nell'endpoint di previsione.

Selezionare Pubblica nel riquadro di spostamento in alto a destra.
Selezionare Slot di produzione e quindi Fatto.
Selezionare il collegamento Accedi agli URL degli endpoint nella notifica per passare alla pagina Risorse di Azure. Sarà possibile visualizzare gli URL solo se all'app è associata una risorsa di previsione. Per passare alla pagina Risorse di Azure, è anche possibile fare clic su Gestisci.

Aggiungere una risorsa di creazione all'app Pizza

Selezionare GESTISCI.
Selezionare Azure Resources (Risorse di Azure).
Selezionare Risorsa Creazione.
Selezionare Change authoring resource (Modifica risorsa Creazione).

Se è disponibile una risorsa Creazione, immettere un valore nei campi Nome del tenant, Nome sottoscrizione e LUIS resource name (Nome risorsa LUIS) della risorsa Creazione.

Se non è disponibile alcuna risorsa Creazione:

Selezionare Crea nuova risorsa.
Immettere un valore in Nome del tenant, Nome della risorsa, Nome sottoscrizione e Nome gruppo di risorse di Azure.

L'app Pizza è ora pronta per essere usata.

Prendere nota dei valori di accesso per l'app Pizza

Per usare la nuova app Pizza, sono necessari l'ID app, la chiave di creazione e l'endpoint di creazione dell'app Pizza. Per ottenere stime, l'endpoint di stima e la chiave di stima dovranno essere separati.

Per trovare questi valori:

Nella pagina Finalità, selezionare GESTISCi.
Nella pagina Impostazioni applicazione, registrare l’ID app.
Selezionare Azure Resources (Risorse di Azure).
Selezionare Risorsa Creazione.
Nelle schede Risorsa di creazione e Risorse di stima, annotare la Chiave primaria. Questo valore corrisponde alla chiave di creazione.
Registrare l’URL dell'endpoint. Questo valore corrisponde all'endpoint di creazione.

Creare un file JSON per eseguire il training dell'app Pizza

Per creare un file JSON con tre espressioni di esempio, salvare i dati JSON seguenti in un file denominato 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
      }
    ]
  }
]`

Il file JSON di espressioni di esempio segue un formato specifico.

Il campo text contiene il testo dell'espressione di esempio. Il campo intentName deve corrispondere al nome di una finalità esistente nell'app di LUIS. Il campo entityLabels è obbligatorio. Se non si desidera assegnare etichette alle entità, fornire una matrice vuota.

Se la matrice entityLabels non è vuota, è necessario che startCharIndex e endCharIndex contrassegnino l'entità a cui si fa riferimento nel campo entityName. L’indice è in base zero. Se si inizia o termina l'etichetta a uno spazio nel testo, la chiamata API per aggiungere le espressioni non riesce.

Aggiungere espressioni di esempio

Per caricare il batch di espressioni di esempio, copiare questo comando nell'editor di testo:

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"

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"

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"

Sostituire i valori che iniziano con ***YOUR- con i propri valori.

Informazioni	Scopo
`*YOUR-AUTHORING-ENDPOINT*`	L'endpoint dell'URL di creazione. Ad esempio: "https://REPLACE-WITH-YOUR-RESOURCE-NAME.api.cognitive.microsoft.com/". Il nome della risorsa è stato impostato quando è stata creata la risorsa.
`*YOUR-APP-ID*`	L'ID app di LUIS.
`*YOUR-APP-VERSION*`	La versione dell'app LUIS. Per l'app Pizza, il numero di versione è "0.1" senza virgolette.
`*YOUR-AUTHORING-KEY*`	La chiave di creazione di 32 caratteri.

Le chiavi e le risorse assegnate sono visibili nel portale LUIS nella sezione Gestisci della pagina Risorse di Azure. L'ID app è disponibile nella stessa sezione Gestisci della pagina Impostazioni applicazione.

Importante

Avviare un prompt dei comandi (Windows) o un terminale (macOS e Linux) e passare alla directory in cui è stato salvato il file ExampleUtterances.JSON.

Copiare il comando cURL dall'editor e incollarlo in un prompt dei comandi (Windows) o in un terminale (macOS e Linux). Premere INVIO per eseguire il comando.

Si dovrebbe vedere la risposta seguente:

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

Ecco l'output formattato per una migliore leggibilità:

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

Eseguire il training del modello di app Pizza

Per iniziare una sessione di training per l'app Pizza, copiare questo comando nell'editor di testo:

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***"

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***"

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***"

Come prima, sostituire i valori che iniziano con ***YOUR- con i propri valori.
Copiare il comando cURL dall'editor e incollarlo in un prompt dei comandi (Windows) o in un terminale (macOS e Linux). Premere INVIO per eseguire il comando.

Si dovrebbe vedere la risposta seguente:
```
{"statusId":2,"status":"UpToDate"}
```
Ecco l'output formattato per una migliore leggibilità:
```
{
  "statusId": 2,
  "status": "UpToDate"
}
```

Ottenere lo stato del training

Per ottenere lo stato della sessione di training, copiare questo comando nell'editor di testo:

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***"

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***"

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***"

Come prima, sostituire i valori che iniziano con ***YOUR- con i propri valori.

Copiare il comando cURL dall'editor e incollarlo in un prompt dei comandi (Windows) o in un terminale (macOS e Linux). Premere INVIO per eseguire il comando.

Si dovrebbe vedere la risposta seguente:

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

Ecco l'output formattato per una migliore leggibilità:

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

Ottenere una finalità dall'endpoint di previsione

Usare cURL per eseguire query sull'endpoint di previsione e ottenere un risultato della previsione.

Nota

Questo comando usa l'endpoint di previsione.

Copiare questo comando nell'editor di testo:

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"

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"

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"

Sostituire i valori che iniziano con ***YOUR- con i propri valori.

Informazioni	Scopo
`*YOUR-PREDICTION-ENDPOINT*`	L'endpoint dell'URL di previsione. Disponibile nel portale LUIS, pagina delle risorse di Azure per l'app. Ad esempio, `https://westus.api.cognitive.microsoft.com/`.
`*YOUR-APP-ID*`	L'ID app. Disponibile nel portale LUIS, pagina Impostazioni applicazione per l'app.
`*YOUR-PREDICTION-KEY*`	La chiave di previsione di 32 caratteri. Disponibile nel portale LUIS, pagina delle risorse di Azure per l'app.

Copiare il testo in una finestra della console e premere INVIO per eseguire il comando:

Esaminare la risposta di previsione restituita in formato 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"]}]}}}}

Risposta JSON formattata per migliorare la leggibilità:

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

Pulire le risorse

È possibile eliminare l'app dal portale LUIS ed eliminare le risorse di Azure dal portale di Azure.

Se si usa l'API REST, eliminare il file ExampleUtterances.JSON dal file system una volta completata la guida di avvio rapido.

Risoluzione dei problemi

Autenticazione alla libreria client: gli errori di autenticazione indicano in genere che sono stati usati un endpoint e una chiave non corretti. Per comodità, questa guida di avvio rapido usa la chiave di creazione e l'endpoint per il runtime di previsione, ma funziona solo se non è già stata usata la quota mensile. Se non è possibile usare la chiave di creazione e l'endpoint, è necessario usare la chiave e l'endpoint del runtime di previsione per accedere alla libreria client di Prediction Runtime SDK.
Creazione di entità: se viene restituito un errore durante la creazione dell'entità di Machine Learning annidata usata in questa esercitazione, assicurarsi di aver copiato il codice senza averlo modificato per creare un'altra entità.
Creazione di espressioni di esempio: se viene restituito un errore durante la creazione dell'espressione di esempio etichettata usata in questa esercitazione, assicurarsi di aver copiato il codice senza averlo modificato per creare un altro esempio etichettato.
Training: un eventuale errore di training in genere indica un'app vuota (senza finalità con espressioni di esempio) o un'app con finalità o entità in formato non valido.
Errori vari: poiché il codice chiama le librerie client con oggetti JSON e di testo, assicurarsi di non aver modificato il codice.

Altri errori: se viene ricevuto un errore non incluso nell'elenco precedente, segnalarlo inviando un feedback nella parte inferiore della pagina. Includere il linguaggio di programmazione e la versione delle librerie client installate.

Passaggi successivi

Sviluppo di app iterative per LUIS

Condividi tramite

Avvio rapido: Librerie client e API REST di Language Understanding (LUIS)

Prerequisiti

Configurazione

Creare una nuova applicazione C#

Installare le librerie NuGet

Modello a oggetti di creazione

Esempi di codice per la creazione

Modello a oggetti di previsione

Esempi di codice per il runtime di previsione

Esempi di codice

Aggiungere le dipendenze

Aggiungere il codice boilerplate

Creare variabili per l'app

Autenticare il client

Creare un'app LUIS

Creare la finalità per l'app

Creare le entità per l'app

Aggiungere un'espressione di esempio alla finalità

Eseguire il training dell'app

Pubblicare l'app nello slot di produzione

Autenticare il client del runtime di previsione

Ottenere previsioni dal runtime

Eseguire l'applicazione

Prerequisiti

Configurazione

Creare una nuova applicazione JavaScript

Installare le librerie NPM

Modello a oggetti di creazione

Esempi di codice per la creazione

Modello a oggetti di previsione

Esempi di codice per il runtime di previsione

Esempi di codice

Aggiungere le dipendenze

Aggiungere il codice boilerplate

Creare variabili per l'app

Autenticare il client

Creare un'app LUIS

Creare la finalità per l'app

Creare le entità per l'app

Aggiungere un'espressione di esempio alla finalità

Eseguire il training dell'app

Pubblicare l'app nello slot di produzione

Autenticare il client del runtime di previsione

Ottenere previsioni dal runtime

Eseguire l'applicazione

Prerequisiti

Configurazione

Creare una nuova applicazione Python

È possibile installare la libreria client con Pip

Modello a oggetti di creazione

Esempi di codice per la creazione

Modello a oggetti di previsione

Esempi di codice per il runtime di previsione

Esempi di codice

Aggiungere le dipendenze

Aggiungere il codice boilerplate

Creare variabili per l'app

Autenticare il client

Creare un'app LUIS

Creare la finalità per l'app

Creare le entità per l'app

Aggiungere un'espressione di esempio alla finalità

Eseguire il training dell'app

Pubblicare l'app nello slot di produzione

Autenticare il client del runtime di previsione

Ottenere previsioni dal runtime

Eseguire l'applicazione

Prerequisiti

Creare l’app Pizza

Eseguire il training dell’app Pizza e pubblicarla

Aggiungere una risorsa di creazione all'app Pizza

Prendere nota dei valori di accesso per l'app Pizza

Creare un file JSON per eseguire il training dell'app Pizza

Aggiungere espressioni di esempio

Eseguire il training del modello di app Pizza

Ottenere lo stato del training

Ottenere una finalità dall'endpoint di previsione

Pulire le risorse

Risoluzione dei problemi