Guida introduttiva: Librerie client LUIS (Language Understanding) e API REST
Importante
LUIS verrà ritirato il 1 ottobre 2025 e a partire dal 1 aprile 2023 non sarà più possibile creare nuove risorse LUIS. Si consiglia di eseguire la migrazione delle applicazioni LUIS a comprensione del linguaggio di conversazione per sfruttare appieno un supporto costante per i prodotti e le funzionalità multilingue.
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).
- 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 (
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
newper creare una nuova app console con il nomelanguage-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-quickstartSpostarsi nella cartella dell'app appena creata.
cd language-understanding-quickstartÈ possibile compilare l'applicazione con il comando seguente:
dotnet buildL'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 la 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
Mainper consentire chiamate asincrone:public static async Task Main()Aggiungere il resto del codice nel metodo
Maindella classeProgramse 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 la 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 dei servizi di intelligenza artificiale di Azure.
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.
// 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.
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
Questa guida introduttiva usa la chiave di creazione come parte delle credenziali di 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 stima NPM | Campioni
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).
- 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 (
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-sdkInizializzare la directory come applicazione JavaScript creando un file
package.json.npm init -yCreare un file denominato
index.jsper 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
stagingoproduction - 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 la 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
quickstarte 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
Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per la 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 dei servizi di intelligenza artificiale di Azure.
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
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.
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
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 un'unica finalità specifica.
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.
// 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à
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.
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
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.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
Questa guida introduttiva usa la chiave di creazione come parte delle credenziali di 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.
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).
- 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 (
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-sdkCreare un file denominato
authoring_and_predict.pyper il codice Python.touch authoring_and_predict.py
È possibile installare la libreria client con Pip
Nella directory dell'applicazione installare la libreria client 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 la 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
quickstarte 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
Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per la 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 dei servizi di intelligenza artificiale di Azure.
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
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.
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
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 un'unica finalità specifica.
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.
# 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à
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.
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
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.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
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à.
# 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
Questa guida introduttiva usa la chiave di creazione come parte delle credenziali di 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.
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 verrà usato per eseguire il training del modello di app Pizza, usando la chiamata REST Batch per aggiungere etichette .
- 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.
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.jsonnel 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.jsonscaricato 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"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
Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per la 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 dei servizi di intelligenza artificiale di Azure.
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***"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***"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"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.