Démarrage rapide : Bibliothèques de client et API REST Language Understanding (LUIS)

Article
01/19/2024

Important

LUIS sera mis hors service le 1er octobre 2025 et à partir du 1er avril 2023, vous ne pourrez plus créer de nouvelles ressources LUIS. Nous vous recommandons de migrer vos applications LUIS vers la compréhension du langage courant pour tirer parti de la prise en charge continue des produits et des fonctionnalités multilingues.

Créez et interrogez une application d’IA Azure LUIS avec les bibliothèques de client du SDK LUIS en utilisant ce guide de démarrage rapide avec C#, Python ou JavaScript. Vous pouvez également utiliser cURL pour envoyer des requêtes à l’aide de l’API REST.

Language Understanding (LUIS) vous permet d’appliquer un traitement en langage naturel au texte en langage naturel des conversations d’un utilisateur afin d’en prédire le sens général, et d’en extraire des informations détaillées et pertinentes.

La bibliothèque de client et l’API REST Authoring vous permettent de créer, modifier, entraîner et publier votre application LUIS.
La bibliothèque de client et l’API REST Prediction Runtime vous permettent d’interroger l’application publiée.

Utilisez les bibliothèques de client LUIS (Language Understanding) pour .NET pour :

Créer une application
Ajouter une intention, une entité issue du Machine Learning, avec un exemple d'énoncé
Entraîner et publier une application.
Interroger un runtime de prédiction

Documentation de référence | Création et Prédiction - Code source de la bibliothèque | Création et Prédiction - NuGet | Exemple C#

Prérequis

Version actuelle de .NET Core et de CLI .NET Core.
Abonnement Azure - En créer un gratuitement
Une fois en possession de votre abonnement Azure, créez une ressource de création LUIS sur le portail Azure pour obtenir vos clé et point de terminaison. Attendez qu’elle se déploie, puis cliquez sur le bouton Accéder à la ressource.
- Vous aurez besoin de la clé et du point de terminaison de la ressource que vous créez pour connecter votre application à la création LUIS. Vous collerez votre clé et votre point de terminaison dans le code ci-dessous plus loin dans le guide de démarrage rapide. Vous pouvez utiliser le niveau tarifaire gratuit (F0) pour tester le service.

Configuration

Créer une application C#

Créez une application .NET Core dans votre éditeur ou IDE favori.

Dans une fenêtre de console (par exemple cmd, PowerShell ou Bash), utilisez la commande new dotnet pour créer une application console avec le nom language-understanding-quickstart. Cette commande crée un projet C# « Hello World » simple avec un seul fichier source : Program.cs.
```
dotnet new console -n language-understanding-quickstart
```
Déplacez vos répertoires vers le dossier d’application nouvellement créé.
```
cd language-understanding-quickstart
```
Vous pouvez générer l’application avec :
```
dotnet build
```
La sortie de génération ne doit contenir aucun avertissement ni erreur.
```
...
Build succeeded.
 0 Warning(s)
 0 Error(s)
...
```

Installer les bibliothèques NuGet

Dans le répertoire de l'application, installez les bibliothèques de client Language Understanding (LUIS) pour .NET à l'aide des commandes suivantes :

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

Modèle d'objet de création

Le client de création Language Understanding (LUIS) est un objet LUISAuthoringClient qui s’authentifie auprès d’Azure et contient votre clé de création.

Exemples de code pour la création

Une fois le client créé, utilisez-le pour accéder aux fonctionnalités, notamment :

Applications : créer, supprimer, publier
Exemples d'énoncés : ajouter, supprimer par ID
Fonctionnalités : gérer les listes d’expressions
Modèle : gérer les intentions et les entités
Modèle : gérer les modèles
Entraînement : entraînez l’application et interrogez l’état de l’entraînement
Versions : gérer avec clonage, exportation et suppression

Modèle d'objet de prédiction

Le client du runtime de prédiction Language Understanding (LUIS) est un objet LUISRuntimeClient qui s’authentifie auprès d’Azure et contient votre clé de ressource.

Exemples de code pour le runtime de prédiction

Une fois le client créé, utilisez-le pour accéder aux fonctionnalités, notamment :

Prédiction par emplacement de préproduction ou de production
Prédiction par version

Exemples de code

Ces extraits de code montrent comment effectuer les opérations suivantes avec la bibliothèque de client Language Understanding (LUIS) pour Python :

Créer une application
Ajouter une intention
Ajouter des entités
Ajouter des exemples d’énoncés
Entraîner l’application
Publier l’application
Prédiction par emplacement

Ajouter les dépendances

À partir du répertoire de projet, ouvrez le fichier Program.cs dans votre éditeur ou votre IDE favori. Remplacez le code using existant par les directives using suivantes :

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;

Ajouter du code réutilisable

Modifiez la signature de la méthode Main pour autoriser les appels asynchrones :
```
public static async Task Main()
```
Sauf indication contraire, ajoutez le reste du code dans la méthode Main de la classe Program.

Créer des variables pour l'application

Créez deux ensembles de variables : le premier ensemble que vous modifiez, le deuxième ensemble qui reste tel qu’il apparaît dans l’exemple de code.

Important

N’oubliez pas de supprimer la clé de votre code une fois que vous avez terminé, et ne la postez jamais publiquement. Pour la production, utilisez un moyen sécurisé de stocker et d’accéder à vos informations d’identification comme Azure Key Vault. Pour plus d’informations, consultez l’article sur la sécurité d’Azure AI services.

Créez des variables pour stocker votre clé de création et les noms de vos ressources.

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

Créez des variables pour stocker vos points de terminaison, le nom de l'application, la version et le nom de l'intention.
```
var appName = "Contoso Pizza Company";
var versionId = "0.1";
var intentName = "OrderPizzaIntent";
```

Authentifier le client

Créez un objet ApiKeyServiceClientCredentials avec votre clé et utilisez-le avec votre point de terminaison pour créer un objet LUISAuthoringClient.

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

Créer une application LUIS

Une application LUIS stocke le modèle de traitement en langage naturel contenant les intentions, les entités et les exemples d'énoncés.

Créez un ApplicationCreateObject. Le nom et la culture de la langue sont des propriétés obligatoires. Appelez la méthode Apps.AddAsync. La réponse est l’ID d’application.

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

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

Créer une intention pour l’application

L’objet principal dans un modèle d’application LUIS est l’intention. L'intention s'aligne sur un regroupement d'intentions d'énoncés utilisateur. Un utilisateur peut poser une question ou émettre un énoncé en souhaitant obtenir une réponse prévue particulière d’un bot (ou d’une autre application cliente). Réserver un billet d’avion, demander quelle est la météo dans une ville de destination et demander des informations de contact pour un service client sont des exemples d’intentions.

Créez un ModelCreateObject avec le nom de l’intention unique, puis transmettez l’ID d’application, l’ID de version et le ModelCreateObject à la méthode Model.AddIntentAsync. La réponse est l’ID d’intention.

La valeur intentName est codée en dur dans OrderPizzaIntent dans le cadre des variables de la section intentName.

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

Créer des entités pour l’application

Bien que les entités ne soient pas obligatoires, elles sont présentes dans la plupart des applications. L’entité extrait des informations à partir de l’énoncé utilisateur, qui sont nécessaires pour répondre à l’intention de l’utilisateur. Il existe plusieurs types d’entités prédéfinies et personnalisées, chacune avec leurs propres modèles DTO (Data Transformation Object). Les entités prédéfinies courantes à ajouter à votre application incluent number, datetimeV2, geographyV2 et ordinal.

Il est important de savoir que les entités ne sont pas marquées avec une intention. Elles peuvent s’appliquer à de nombreuses intentions. Seuls les exemples d'énoncés utilisateur sont marqués pour une intention unique spécifique.

Les méthodes de création pour les entités font partie de la classe Model. Chaque type d’entité a son propre modèle DTO, qui contient généralement le mot model dans l’espace de noms model.

Le code de création d'entité crée une entité de Machine Learning avec des sous-entités et des fonctionnalités appliquées aux sous-entités Quantity.

Partial screenshot from portal showing the entity created, a machine-learning entity with subentities and features applied to the `Quantity` subentities.

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

Appliquez la méthode suivante à la classe pour trouver l’ID de la sous-entité Quantity, afin d’attribuer les fonctionnalités à cette sous-entité.

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

Ajouter un exemple d’énoncé à une intention

Pour déterminer l’intention d’un énoncé et extraire des entités, l’application a besoin d’exemples d’énoncés. Les exemples doivent cibler une intention spécifique et unique, et doivent marquer toutes les entités personnalisées. Les entités prédéfinies n’ont pas besoin d’être marquées.

Ajoutez des exemples d’énoncés en créant une liste d’objets ExampleLabelObject, un objet pour chaque exemple d’énoncé. Chaque exemple doit marquer toutes les entités avec un dictionnaire de paires nom/valeur de nom d’entité et de valeur d’entité. La valeur de l’entité doit être exactement telle qu’elle apparaît dans le texte de l’exemple d’énoncé.

Partial screenshot showing the labeled example utterance in the portal.

Appelez Examples.AddAsync avec l'ID de l'application, l'ID de version et l'exemple.

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

Effectuer l’apprentissage de l’application

Une fois le modèle créé, l’application LUIS doit être entraînée pour cette version du modèle. Un modèle entraîné peut être utilisé dans un conteneur ou publié dans les emplacements intermédiaires ou produits.

La méthode Train.TrainVersionAsync a besoin de l’ID d’application et de l’ID de version.

Un modèle très petit, comme l’illustre ce guide de démarrage rapide, sera entraîné très rapidement. Pour les applications de niveau production, l’entraînement de l’application doit inclure un appel d’interrogation à la méthode GetStatusAsync pour déterminer si l’entraînement a réussi. La réponse est une liste d’objets ModelTrainingInfo avec un état distinct pour chaque objet. Tous les objets doivent réussir pour que l’entraînement soit considéré comme terminé.

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

Publier une application dans l’emplacement de production

Publiez l’application LUIS à l’aide de la méthode PublishAsync. Cela permet de publier la version entraînée actuelle à l’emplacement spécifié au point de terminaison. Votre application cliente utilise ce point de terminaison afin d’envoyer des énoncés utilisateur pour la prédiction de l’intention et l’extraction d’entité.

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

Authentifier le client du runtime de prédiction

Utilisez un objet ApiKeyServiceClientCredentials avec votre clé, et utilisez-le avec votre point de terminaison pour créer un objet LUISRuntimeClient.

Attention

Ce guide de démarrage rapide utilise la clé de création dans le cadre des informations d’identification du runtime. La clé de création est autorisée à adresser quelques requêtes au runtime. Pour le code du niveau intermédiaire et du niveau de production, remplacez la clé de création par une clé de runtime de prédiction.

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

Obtenir une prédiction du runtime

Ajoutez le code suivant pour créer la requête à adresser au runtime de prédiction.

L’énoncé utilisateur fait partie de l’objet PredictionRequest.

La méthode GetSlotPredictionAsync a besoin de plusieurs paramètres, comme appID (ID d’application), slotName ( nom d’emplacement), l’objet predictionRequest (demande de prédiction), pour satisfaire la demande. Les autres options que sont verbose (mode détaillé), showAllIntents (afficher toutes les intentions) et log (journal) sont facultatives.

// 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 réponse de prédiction est un objet JSON comprenant l'intention et toutes les entités trouvées.

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

Exécution de l'application

Exécutez l’application avec la commande dotnet run à partir du répertoire de votre application.

dotnet run

Utilisez les bibliothèques de client LUIS (Language Understanding) pour Node.js pour :

Créer une application
Ajouter une intention, une entité issue du Machine Learning, avec un exemple d'énoncé
Entraîner et publier une application.
Interroger un runtime de prédiction

Documentation de référence | Création et Prévision NPM | Échantillons

Prérequis

Node.JS
Abonnement Azure - En créer un gratuitement
Une fois en possession de votre abonnement Azure, créez une ressource de création LUIS sur le portail Azure pour obtenir vos clé et point de terminaison. Attendez qu’elle se déploie, puis cliquez sur le bouton Accéder à la ressource.
- Vous aurez besoin de la clé et du point de terminaison de la ressource que vous créez pour connecter votre application à la création LUIS. Vous collerez votre clé et votre point de terminaison dans le code ci-dessous plus loin dans le guide de démarrage rapide. Vous pouvez utiliser le niveau tarifaire gratuit (F0) pour tester le service.

Configuration

Créer une application JavaScript

Dans une fenêtre de console, créez un nouveau répertoire pour votre application et déplacez-vous dans ce répertoire.
```
mkdir quickstart-sdk && cd quickstart-sdk
```
Initialisez le répertoire en tant qu'application JavaScript en créant un fichier package.json.
```
npm init -y
```
Créez un fichier nommé index.js pour votre code JavaScript.
```
touch index.js
```

Installer les bibliothèques NPM

Dans le répertoire de l'application, installez les dépendances à l'aide des commandes suivantes, exécutées une ligne à la fois :

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

Votre package.json doit se présenter comme suit :

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

Modèle d'objet de création

Le client de création Language Understanding (LUIS) est un objet LUISAuthoringClient qui s’authentifie auprès d’Azure et contient votre clé de création.

Exemples de code pour la création

Une fois le client créé, utilisez-le pour accéder aux fonctionnalités, notamment :

Applications : add, delete, publish
Exemples d’énoncés : ajouter par lot, supprimer par ID
Fonctionnalités : gérer les listes d’expressions
Modèle : gérer les intentions et les entités
Modèle : gérer les modèles
Entraînement : entraînez l’application et interrogez l’état de l’entraînement
Versions : gérer avec clonage, exportation et suppression

Modèle d'objet de prédiction

Le client de création Language Understanding (LUIS) est un objet LUISAuthoringClient qui s’authentifie auprès d’Azure et contient votre clé de création.

Exemples de code pour le runtime de prédiction

Une fois le client créé, utilisez-le pour accéder aux fonctionnalités, notamment :

Prédiction par emplacement de staging ou de production
Prédiction par version

Exemples de code

Ces extraits de code montrent comment effectuer les opérations suivantes avec la bibliothèque de client Language Understanding (LUIS) pour Python :

Créer une application
Ajouter une intention
Ajouter des entités
Ajouter des exemples d’énoncés
Entraîner l’application
Publier l’application
Prédiction par emplacement

Ajouter les dépendances

Ouvrez le fichier index.js dans votre éditeur ou IDE préféré, puis ajoutez les dépendances suivantes.

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

Ajouter du code réutilisable

Ajoutez la méthode quickstart et son appel. Cette méthode contient la majeure partie du code restant. Cette méthode est appelée à la fin du fichier.

const quickstart = async () => {

    // add calls here


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

Sauf indication contraire, ajoutez le code restant dans la méthode de démarrage rapide.

Créer des variables pour l'application

Créez deux ensembles de variables : le premier ensemble que vous modifiez, le deuxième ensemble qui reste tel qu’il apparaît dans l’exemple de code.

Important

Créez des variables pour stocker votre clé de création et les noms de vos ressources.

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

Créez des variables pour stocker vos points de terminaison, le nom de l'application, la version et le nom de l'intention.
```
const appName = "Contoso Pizza Company";
const versionId = "0.1";
const intentName = "OrderPizzaIntent";
```

Authentifier le client

Créez un objet CognitiveServicesCredentials avec votre clé et utilisez-le avec votre point de terminaison pour créer un objet LUISAuthoringClient.

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

Créer une application LUIS

Une application LUIS stocke le modèle de traitement en langage naturel contenant les intentions, les entités et les exemples d'énoncés.

Créez une méthode add pour l’objet AppsOperation afin de créer l’application. Le nom et la culture de la langue sont des propriétés obligatoires.

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

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

const appId = createAppResult.body

Créer une intention pour l’application

L’objet principal dans un modèle d’application LUIS est l’intention. L’intention s’aligne sur un regroupement d’intentions d’énoncés utilisateur. Un utilisateur peut poser une question ou émettre un énoncé en souhaitant obtenir une réponse prévue particulière d’un bot (ou d’une autre application cliente). Réserver un billet d’avion, demander quelle est la météo dans une ville de destination et demander des informations de contact pour un service client sont des exemples d’intentions.

Utilisez la méthode model.add_intent avec le nom de l’intention unique, puis transmettez l’ID de l’application, l’ID de version et le nom de la nouvelle intention.

La valeur intentName est codée en dur dans OrderPizzaIntent dans le cadre des variables de la section intentName.

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

Créer des entités pour l’application

Il est important de savoir que les entités ne sont pas marquées avec une intention. Elles peuvent s’appliquer à de nombreuses intentions. Seuls les exemples d’énoncés utilisateur sont marqués pour une intention unique spécifique.

Les méthodes de création pour les entités font partie de la classe Model. Chaque type d’entité possède son propre modèle DTO (Data Transformation Object).

Le code de création d'entité crée une entité de Machine Learning avec des sous-entités et des fonctionnalités appliquées aux sous-entités Quantity.

Partial screenshot from portal showing the entity created, a machine-learning entity with subentities and features applied to the `Quantity` subentities.

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

Placez la méthode suivante au-dessus de la méthode quickstart pour trouver l’ID de la sous-entité Quantity, afin d’attribuer les fonctionnalités à cette sous-entité.

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

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

}

Ajouter un exemple d’énoncé à une intention

Partial screenshot showing the labeled example utterance in the portal.

Appelez examples.add avec l'ID de l'application, l'ID de version et l'exemple.

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

Effectuer l’apprentissage de l’application

La méthode train.trainVersion a besoin de l’ID d’application et de l’ID de version.

Un modèle très petit, comme l’illustre ce guide de démarrage rapide, sera entraîné très rapidement. Pour les applications de niveau production, l’entraînement de l’application doit inclure un appel d’interrogation à la méthode get_status pour déterminer si l’entraînement a réussi. La réponse est une liste d’objets ModelTrainingInfo avec un état distinct pour chaque objet. Tous les objets doivent réussir pour que l’entraînement soit considéré comme terminé.

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

Publier une application dans l’emplacement de production

Publiez l’application LUIS à l’aide de la méthode app.publish. Cela permet de publier la version entraînée actuelle à l’emplacement spécifié au point de terminaison. Votre application cliente utilise ce point de terminaison afin d’envoyer des énoncés utilisateur pour la prédiction de l’intention et l’extraction d’entité.

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

Authentifier le client du runtime de prédiction

Utilisez un objet msRest.ApiKeyCredentials avec votre clé, puis utilisez-le avec votre point de terminaison pour créer un objet LUIS.LUISRuntimeClient.

Attention

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

Obtenir une prédiction du runtime

Ajoutez le code suivant pour créer la requête à adresser au runtime de prédiction. L’énoncé utilisateur fait partie de l’objet predictionRequest.

La méthode luisRuntimeClient.prediction.getSlotPrediction nécessite plusieurs paramètres tels que l’ID de l’application, le nom de l’emplacement et l’objet de requête de prédiction pour traiter la requête. Les autres options que sont verbose (mode détaillé), showAllIntents (afficher toutes les intentions) et log (journal) sont facultatives.

// 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 réponse de prédiction est un objet JSON comprenant l'intention et toutes les entités trouvées.

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

Exécution de l'application

Exécutez l’application avec la commande node index.js de votre fichier de démarrage rapide.

node index.js

Utilisez les bibliothèques de client LUIS (Language Understanding) pour Python pour :

Créer une application
Ajouter une intention, une entité issue du Machine Learning, avec un exemple d'énoncé
Entraîner et publier une application.
Interroger un runtime de prédiction

Documentation de référence | Création et Prédiction - Code source de la bibliothèque | Package (Pypi) | Exemples

Prérequis

Version actuelle de Python 3.x.
Abonnement Azure - En créer un gratuitement
Une fois en possession de votre abonnement Azure, créez une ressource de création LUIS sur le portail Azure pour obtenir vos clé et point de terminaison. Attendez qu’elle se déploie, puis cliquez sur le bouton Accéder à la ressource.
- Vous aurez besoin de la clé et du point de terminaison de la ressource que vous créez pour connecter votre application à la création LUIS. Vous collerez votre clé et votre point de terminaison dans le code ci-dessous plus loin dans le guide de démarrage rapide. Vous pouvez utiliser le niveau tarifaire gratuit (F0) pour tester le service.

Configuration

Créer une application Python

Dans une fenêtre de console, créez un nouveau répertoire pour votre application et déplacez-vous dans ce répertoire.
```
mkdir quickstart-sdk && cd quickstart-sdk
```
Créez un fichier nommé authoring_and_predict.py pour votre code Python.
```
touch authoring_and_predict.py
```

Installer la bibliothèque de client avec Pip

Dans le répertoire de l’application, installez la bibliothèque de client Language Understanding (LUIS) pour Python à l’aide de la commande suivante :

pip install azure-cognitiveservices-language-luis

Modèle d'objet de création

Le client de création Language Understanding (LUIS) est un objet LUISAuthoringClient qui s’authentifie auprès d’Azure et contient votre clé de création.

Exemples de code pour la création

Une fois le client créé, utilisez-le pour accéder aux fonctionnalités, notamment :

Applications : créer, supprimer, publier
Exemples d’énoncés : ajouter par lot, supprimer par ID
Fonctionnalités : gérer les listes d’expressions
Modèle : gérer les intentions et les entités
Modèle : gérer les modèles
Entraînement : entraînez l’application et interrogez l’état de l’entraînement
Versions : gérer avec clonage, exportation et suppression

Modèle d'objet de prédiction

Le client du runtime de prédiction Language Understanding (LUIS) est un objet LUISRuntimeClient qui s’authentifie auprès d’Azure et contient votre clé de ressource.

Exemples de code pour le runtime de prédiction

Une fois le client créé, utilisez-le pour accéder aux fonctionnalités, notamment :

Prédiction par emplacement de préproduction ou de production
Prédiction par version

Exemples de code

Ces extraits de code montrent comment effectuer les opérations suivantes avec la bibliothèque de client Language Understanding (LUIS) pour Python :

Créer une application
Ajouter une intention
Ajouter des entités
Ajouter des exemples d’énoncés
Entraîner l’application
Publier l’application
Prédiction par emplacement

Ajouter les dépendances

Ajoutez les bibliothèques de client au fichier 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

Ajouter du code réutilisable

Ajoutez la méthode quickstart et son appel. Cette méthode contient la majeure partie du code restant. Cette méthode est appelée à la fin du fichier.
```
def quickstart():

    # add calls here, remember to indent properly

quickstart()
```
Sauf indication contraire, ajoutez le code restant dans la méthode de démarrage rapide.

Créer des variables pour l'application

Créez deux ensembles de variables : le premier ensemble que vous modifiez, le deuxième ensemble qui reste tel qu’il apparaît dans l’exemple de code.

Important

Créez des variables pour stocker votre clé de création et les noms de vos ressources.

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'

Créez des variables pour stocker vos points de terminaison, le nom de l'application, la version et le nom de l'intention.

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

Authentifier le client

Créez un objet CognitiveServicesCredentials avec votre clé et utilisez-le avec votre point de terminaison pour créer un objet LUISAuthoringClient.

client = LUISAuthoringClient(authoringEndpoint, CognitiveServicesCredentials(authoringKey))

Créer une application LUIS

Une application LUIS stocke le modèle de traitement en langage naturel contenant les intentions, les entités et les exemples d'énoncés.

Créez une méthode add pour l’objet AppsOperation afin de créer l’application. Le nom et la culture de la langue sont des propriétés obligatoires.

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

Créer une intention pour l’application

Utilisez la méthode model.add_intent avec le nom de l’intention unique, puis transmettez l’ID de l’application, l’ID de version et le nom de la nouvelle intention.

La valeur intentName est codée en dur dans OrderPizzaIntent dans le cadre des variables de la section intentName.

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

Créer des entités pour l’application

Les méthodes de création pour les entités font partie de la classe ModelOperations. Chaque type d’entité possède son propre modèle DTO (Data Transformation Object).

Le code de création d'entité crée une entité de Machine Learning avec des sous-entités et des fonctionnalités appliquées aux sous-entités Quantity.

Partial screenshot from portal showing the entity created, a machine-learning entity with subentities and features applied to the `Quantity` subentities.

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

Placez la méthode suivante au-dessus de la méthode quickstart pour trouver l’ID de la sous-entité Quantity, afin d’attribuer les fonctionnalités à cette sous-entité.

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

Ajouter un exemple d’énoncé à une intention

Partial screenshot showing the labeled example utterance in the portal.

Appelez examples.add avec l'ID de l'application, l'ID de version et l'exemple.

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

Effectuer l’apprentissage de l’application

La méthode train.train_version a besoin de l’ID de l’application et de l’ID de version.

Un modèle très petit, comme l’illustre ce guide de démarrage rapide, sera entraîné très rapidement. Pour les applications de niveau production, l’entraînement de l’application doit inclure un appel d’interrogation à la méthode get_status pour déterminer si l’entraînement a réussi. La réponse est une liste d’objets ModelTrainingInfo avec un état distinct pour chaque objet. Tous les objets doivent réussir pour que l’entraînement soit considéré comme terminé.

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

Publier une application dans l’emplacement de production

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

Authentifier le client du runtime de prédiction

Utilisez l'objet d'informations d'identification avec votre clé, puis utilisez-le avec votre point de terminaison pour créer un objet LUISRuntimeClientConfiguration.

Attention

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

Obtenir une prédiction du runtime

Ajoutez le code suivant pour créer la requête à adresser au runtime de prédiction.

L’énoncé utilisateur fait partie de l’objet prediction_request.

La méthode get_slot_prediction nécessite plusieurs paramètres tels que l’ID de l’application, le nom de l’emplacement et l’objet de requête de prédiction pour traiter la requête. Les autres options que sont verbose (mode détaillé), showAllIntents (afficher toutes les intentions) et log (journal) sont facultatives. La requête retourne un objet 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 réponse de prédiction est un objet JSON comprenant l'intention et toutes les entités trouvées.

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

Exécution de l'application

Exécutez l’application avec la commande python de votre fichier de démarrage rapide.

python authoring_and_predict.py

En suivant ce guide de démarrage rapide, vous effectuez trois appels REST à la suite.

Tout d’abord, vous chargez un lot d’exemples d’énoncés destinés à l’entraînement du modèle de l’application de pizza, en utilisant l’appel REST Batch add labels.
Ensuite, vous commencez une session d’entraînement de l’application de pizza, en utilisant l’appel REST Train application version.
Enfin, vous obtenez l’état de la session d’entraînement de l’application de pizza, en utilisant l’appel REST Get version training status.

Documentation de référence

Prérequis

Un compte LUIS gratuit.
Un éditeur de texte, par exemple Visual Studio Code.
Le programme en ligne de commande cURL. Le programme cURL est préinstallé sur macOS, sur la plupart des distributions Linux ainsi que sur Windows 10 build 1803 et ultérieur.

Si vous devez installer le programme cURL, téléchargez-le à partir de la page de téléchargement de cURL.

Créer une application de pizza

Créez l’application de pizza.

Sélectionnez pizza-app-for-luis-v6.json pour afficher la page GitHub du fichier pizza-app-for-luis.json.
Cliquez avec le bouton droit ou appuyez longuement sur le bouton Raw et sélectionnez Enregistrer la cible sous pour enregistrer le fichier pizza-app-for-luis.json sur votre ordinateur.
Connectez-vous au portail LUIS.
Sélectionnez My Apps (Mes applications).
Dans la page My Apps, sélectionnez + New app for conversation (Nouvelle application pour la conversation).
Sélectionnez Import as JSON (Importer en tant que JSON).
Dans la boîte de dialogue Import new app (Importer une nouvelle application), sélectionnez le bouton Choose File (Choisir un fichier).
Sélectionnez le fichier pizza-app-for-luis.json que vous avez téléchargé, puis sélectionnez pizza-app-for-luis.json (Ouvrir).
Dans le champ Name (Nom) de la boîte de dialogue Import new app, entrez un nom pour votre application de pizza, puis sélectionnez le bouton Done (terminé).

L’application est importée.

Si apparaît une boîte de dialogue How to create an effective LUIS app (Comment créer une application LUIS efficace), fermez-la.

Entraîner et publier l’application de pizza

Vous devez voir la page Intents (Intentions) avec une liste des intentions de l’application de pizza.

En haut à droite du site web LUIS, sélectionnez le bouton Effectuer l’apprentissage.
L’entraînement est terminé quand le bouton Entraîner est désactivé.

Pour recevoir une prédiction LUIS dans un chatbot ou une autre application cliente, vous avez besoin de publier l’application sur le point de terminaison de prédiction.

Dans le volet de navigation supérieur droit, sélectionnez Publier.
Sélectionnez l’emplacement Production, puis sélectionnez Terminé.
Sélectionnez Accéder à vos URL de point de terminaison dans la notification pour accéder à la page Ressources Azure. Vous ne pouvez voir les URL que si vous disposez d’une ressource de prédiction associée à l’application. Vous pouvez également rechercher la page Ressources Azure en cliquant sur Gérer.

Ajouter une ressource de création à l’application Pizza

Sélectionnez MANAGE (Gérer).
Sélectionnez Azure Resources (Ressources Azure).
Sélectionnez Authoring Resource (Ressource de création).
Sélectionnez Change authoring resource (Changer la ressource de création).

Si vous disposez d’une ressource de création, entrez le nom du locataire, le nom de l’abonnement, puis le nom de la ressource LUIS de votre ressource de création.

Si vous n’avez pas de ressource de création :

Sélectionnez Create new resource (Créer une ressource).
Entrez un nom de locataire, un nom de ressource, un nom d’abonnement et un nom de groupe de ressources Azure.

Votre application de pizza est maintenant prête à être utilisée.

Enregistrer les valeurs d’accès pour votre application Pizza

Pour utiliser votre nouvelle application de pizza, vous aurez besoin de son ID d’application, de sa clé de création et de son point de terminaison de création. Pour obtenir des prédictions, vous aurez besoin de votre propre point de terminaison de prédiction et de votre propre clé de prédiction.

Pour rechercher ces valeurs :

Dans la page Intents (Intentions), sélectionnez MANAGE (GÉRER).
Dans la page Application Settings (Paramètres de l’application), enregistrez l’ID d’application.
Sélectionnez Azure Resources (Ressources Azure).
Sélectionnez Authoring Resource (Ressource de création).
Sous les onglets Ressource de création et Ressources de prédiction, enregistrez la Clé primaire. Cette valeur est votre clé de création.
Enregistrez l’URL du point de terminaison. Cette valeur est votre point de terminaison de création.

Créer un fichier JSON pour l’entraînement de l’application de pizza

Pour créer un fichier JSON avec trois exemples d’énoncés, enregistrez les données JSON suivantes dans un fichier nommé 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
      }
    ]
  }
]`

Le fichier JSON d’exemples d’énoncés a un format spécifique.

Le champ text contient le texte de l’exemple d’énoncé. Le champ intentName doit correspondre au nom d’une intention existante dans l’application LUIS. Le champ entityLabels est obligatoire. Si vous ne souhaitez étiqueter aucune entité, fournissez un tableau vide.

Si le tableau entityLabels n’est pas vide, les éléments startCharIndex et endCharIndex doivent marquer l’entité concernée dans le champ entityName. L’index est basé sur zéro. Si vous commencez ou terminez l’étiquette au niveau d’un espace dans le texte, l’appel d’API pour ajouter les énoncés échoue.

Ajouter des exemples d’énoncés

Pour charger le lot d’exemples d’énoncés, copiez cette commande dans votre éditeur de texte :

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"

Remplacez les valeurs commençant par ***YOUR- par vos propres valeurs.

Information	Objectif
`*YOUR-AUTHORING-ENDPOINT*`	L’URL de votre point de terminaison de création. Par exemple : "https://REPLACE-WITH-YOUR-RESOURCE-NAME.api.cognitive.microsoft.com/". Vous avez défini le nom de votre ressource au moment de sa création.
`*YOUR-APP-ID*`	Votre ID d’application LUIS.
`*YOUR-APP-VERSION*`	La version de votre application LUIS. Pour l’application de pizza, indiquez le numéro de version « 0.1 » (sans les guillemets).
`*YOUR-AUTHORING-KEY*`	Votre clé de création (32 caractères).

Les ressources et les clés affectées sont visibles dans le portail LUIS, dans la section Gérer de la page Ressources Azure. L’ID d’application est indiqué dans la section Gérer de la page Paramètres de l’application.

Important

Démarrez une invite de commandes (Windows) ou un terminal (macOS et Linux), puis changez les répertoires par le répertoire où vous avez enregistré le fichier ExampleUtterances.JSON.

Copiez la commande cURL à partir de l’éditeur et collez-la dans l’invite de commandes (Windows) ou le terminal (macOS et Linux). Appuyez sur Entrée pour exécuter la commande.

Vous devez normalement voir la réponse suivante :

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

Voici la sortie mise en forme pour être lisible :

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

Entraîner le modèle de l’application de pizza

Pour commencer une session d’entraînement de l’application de pizza, copiez cette commande dans votre éditeur de texte :

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

Comme vous l’avez fait avant, remplacez les valeurs commençant par ***YOUR- par vos propres valeurs.
Copiez la commande cURL à partir de l’éditeur et collez-la dans l’invite de commandes (Windows) ou le terminal (macOS et Linux). Appuyez sur Entrée pour exécuter la commande.

Vous devez normalement voir la réponse suivante :
```
{"statusId":2,"status":"UpToDate"}
```
Voici la sortie mise en forme pour être lisible :
```
{
  "statusId": 2,
  "status": "UpToDate"
}
```

Obtenir l’état de l’entraînement

Pour obtenir l’état de l’entraînement durant la session d’entraînement, copiez cette commande dans votre éditeur de texte :

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

Comme vous l’avez fait avant, remplacez les valeurs commençant par ***YOUR- par vos propres valeurs.

Copiez la commande cURL à partir de l’éditeur et collez-la dans l’invite de commandes (Windows) ou le terminal (macOS et Linux). Appuyez sur Entrée pour exécuter la commande.

Vous devez normalement voir la réponse suivante :

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

Voici la sortie mise en forme pour être lisible :

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

Obtenir une intention auprès du point de terminaison de prédiction

Utilisez cURL pour interroger le point de terminaison de prédiction afin d’obtenir le résultat de la prédiction.

Notes

Cette commande utilise votre point de terminaison de prédiction.

Copiez cette commande dans votre éditeur de texte :

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"

Remplacez les valeurs commençant par ***YOUR- par vos propres valeurs.

Information	Objectif
`*YOUR-PREDICTION-ENDPOINT*`	L’URL de votre point de terminaison de prédiction. Elle se trouve sur le portail LUIS, dans la page Ressources Azure associée à votre application. Par exemple : `https://westus.api.cognitive.microsoft.com/`.
`*YOUR-APP-ID*`	Votre ID d’application. Il se trouve sur le portail LUIS, dans la page Paramètres d’application associée à votre application.
`*YOUR-PREDICTION-KEY*`	Votre clé de prédiction (32 caractères). Elle se trouve sur le portail LUIS, dans la page Ressources Azure associée à votre application.

Copiez le texte dans une fenêtre de la console et appuyez sur Entrée pour exécuter la commande :

Examinez la réponse de prédiction, qui est retournée au format 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"]}]}}}}

La réponse JSON mise en forme pour des raisons de lisibilité :

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

Nettoyer les ressources

Vous pouvez supprimer l’application à partir du portail LUIS et supprimer les ressources Azure du portail Azure.

Si vous utilisez l’API REST, vous devrez supprimer le fichier ExampleUtterances.JSON du système de fichiers à la fin de ce guide de démarrage rapide.

Dépannage

Authentification auprès de la bibliothèque de client : les erreurs d’authentification indiquent généralement qu’une clé et un point de terminaison incorrects ont été utilisés. Pour des raisons pratiques, ce guide de démarrage rapide utilise la clé de création et le point de terminaison de création pour le runtime de prédiction, mais cela fonctionnera seulement si vous n’avez pas déjà utilisé le quota mensuel. Si vous ne pouvez pas utiliser la clé et le point de terminaison de création, vous devez utiliser la clé et le point de terminaison du runtime de prédiction lors de l’accès à la bibliothèque de client du SDK du runtime de prédiction.
Création d’entités : si vous obtenez une erreur lors de la création de l’entité de machine learning imbriquée utilisée dans ce tutoriel, vérifiez que vous avez copié le code et que vous ne l’avez pas modifié pour créer une entité différente.
Création d’exemples d’énoncés : si vous obtenez une erreur lors de la création de l’exemple d’énoncé étiqueté utilisé dans ce tutoriel, vérifiez que vous avez copié le code et que vous ne l’avez pas modifié pour créer un exemple étiqueté différent.
Entraînement : si vous obtenez une erreur d’entraînement, cela indique généralement une application vide (sans intentions avec les exemples d’énoncés) ou une application avec des intentions ou des entités mal formées.
Erreurs diverses : étant donné que le code appelle les bibliothèques de client avec du texte et des objets JSON, vérifiez que vous n’avez pas modifié le code.

Autres erreurs : si une erreur non couverte dans la liste précédente s’affiche, faites-le nous savoir en indiquant vos commentaires en bas de cette page. Incluez le langage de programmation et la version des bibliothèques de client que vous avez installés.

Étapes suivantes

Développement itératif d'applications pour LUIS