Snabb start: Language Understanding (LUIS) redigering av klient bibliotek för pythonQuickstart: Language Understanding (LUIS) authoring client library for Python

Kom igång med klient biblioteket Language Understanding (LUIS) Authoring för python.Get started with the Language Understanding (LUIS) authoring client library for python. Följ de här stegen för att installera paketet och prova exempel koden för grundläggande uppgifter.Follow these steps to install the package and try out the example code for basic tasks. Med Language Understanding (LUIS) kan du använda anpassad maskin inlärnings information till en användares svars-och naturligt språk text för att förutsäga den övergripande innebörden och hämta relevant, detaljerad information.Language Understanding (LUIS) enables you to apply custom machine-learning intelligence to a user's conversational, natural language text to predict overall meaning, and pull out relevant, detailed information.

Använd det Language Understanding (LUIS) redigerings klient biblioteket för python för att:Use the Language Understanding (LUIS) authoring client library for Python to:

  • Skapa en app.Create an app.
  • Lägg till avsikter, entiteter och exempel yttranden.Add intents, entities, and example utterances.
  • Lägg till funktioner, till exempel en fras lista.Add features, such as a phrase list.
  • Träna och publicera en app.Train and publish an app.

Referens dokumentation | biblioteks käll kod | redigerings paket (pypi) | exempelReference documentation | Library source code | Authoring Package (Pypi) | Samples

Nödvändiga komponenterPrerequisites

KonfigureraSetting up

Hämta din Language Understandings start nyckel (LUIS)Get your Language Understanding (LUIS) starter key

Hämta din Start nyckeloch skapa en miljö variabel för nyckeln, med namnet LUIS_AUTHORING_KEY och en miljö variabel för nyckelns region LUIS_REGION.Get your starter key, and create an environment variable for the key, named LUIS_AUTHORING_KEY and an environment variable for the region of the key, LUIS_REGION.

Installera python-biblioteket för LUISInstall the Python library for LUIS

I program katalogen installerar du klient biblioteket Language Understanding (LUIS) för python med följande kommando:Within the application directory, install the Language Understanding (LUIS) authoring client library for python with the following command:

pip install azure-cognitiveservices-language-luis

Objekt modellObject model

Redigerings klienten för Language Understanding (LUIS) är ett LUISAuthoringClient -objekt som autentiserar till Azure, som innehåller din redigerings nyckel.The Language Understanding (LUIS) authoring client is a LUISAuthoringClient object that authenticates to Azure, which contains your authoring key.

När klienten har skapats använder du den här klienten för att få åtkomst till funktioner, inklusive:Once the client is created, use this client to access functionality including:

Kod exempelCode examples

De här kodfragmenten visar hur du gör följande med redigerings klient biblioteket Language Understanding (LUIS) för python:These code snippets show you how to do the following with the Language Understanding (LUIS) authoring client library for python:

Skapa ett nytt python-programCreate a new python application

Skapa ett nytt python-program i önskat redigerings program eller IDE.Create a new Python application in your preferred editor or IDE. Importera sedan följande bibliotek.Then import the following libraries.

from azure.cognitiveservices.language.luis.authoring import LUISAuthoringClient
from msrest.authentication import CognitiveServicesCredentials

import datetime, json, os, time

Skapa variabler för resursens Azure-slutpunkt och nyckel.Create variables for your resource's Azure endpoint and key. Om du har skapat miljövariabeln efter att du har startat programmet måste du stänga och öppna redigerings programmet, IDE eller gränssnittet som kör det för att få åtkomst till variabeln.If you created the environment variable after you launched the application, you will need to close and reopen the editor, IDE, or shell running it to access the variable.

key_var_name = 'LUIS_AUTHORING_KEY'
if not key_var_name in os.environ:
    raise Exception('Please set/export the environment variable: {}'.format(key_var_name))
authoring_key = os.environ[key_var_name]

region_var_name = 'LUIS_REGION'
if not region_var_name in os.environ:
    raise Exception('Please set/export the environment variable: {}'.format(region_var_name))
region = os.environ[region_var_name]
endpoint = "https://{}.api.cognitive.microsoft.com".format(region)

Autentisera klientenAuthenticate the client

Skapa ett CognitiveServicesCredentials -objekt med din nyckel och Använd den med slut punkten för att skapa ett LUISAuthoringClient -objekt.Create an CognitiveServicesCredentials object with your key, and use it with your endpoint to create an LUISAuthoringClient object.

# Instantiate a LUIS client
client = LUISAuthoringClient(endpoint, CognitiveServicesCredentials(authoring_key))

Skapa en LUIS-appCreate a LUIS app

  1. Skapa en LUIS-app som innehåller NLP-modellen (Natural Language Processing), entiteter och exempel yttranden.Create a LUIS app to contain the natural language processing (NLP) model holding intents, entities, and example utterances.

  2. Skapa appen genom att skapa ett AppsOperation -objekts Add -metod.Create a AppsOperation object's add method to create the app. Namnet och språk kulturen är obligatoriska egenskaper.The name and language culture are required properties.

    def create_app():
        # Create a new LUIS app
        app_name    = "Contoso {}".format(datetime.datetime.now())
        app_desc    = "Flight booking app built with LUIS Python SDK."
        app_version = "0.1"
        app_locale  = "en-us"
    
        app_id = client.apps.add(dict(name=app_name,
                                        initial_version_id=app_version,
                                        description=app_desc,
                                        culture=app_locale))
    
        print("Created LUIS app {}\n    with ID {}".format(app_name, app_id))
        return app_id, app_version
    

Skapa avsikt för appenCreate intent for the app

Det primära objektet i en LUIS-Apps modell är avsikten.The primary object in a LUIS app's model is the intent. Avsikten med en gruppering av användarens uttryck.The intent aligns's with a grouping of user utterance intentions. En användare kan ställa en fråga eller göra en instruktion som söker efter ett särskilt avsett svar från en robot (eller något annat klient program).A user may ask a question, or make a statement looking for a particular intended response from a bot (or other client application). Exempel på avsikt är att boka en flygning och fråga om väder i en destinations ort och fråga om kontakt information för kund tjänst.Examples of intentions are booking a flight, asking about weather in a destination city, and asking about contact information for customer service.

Använd metoden Model. Add _intent med namnet på den unika avsikten och skicka sedan appens ID, VERSIONS-ID och nytt namn för avsikten.Use the model.add_intent method with the name of the unique intent then pass the app ID, version ID, and new intent name.

def add_intents(app_id, app_version):
    intentId = client.model.add_intent(app_id, app_version, "FindFlights")

    print("Intent FindFlights {} added.".format(intentId))

Skapa entiteter för appenCreate entities for the app

Även om entiteter inte krävs finns de i de flesta appar.While entities are not required, they are found in most apps. Entiteten extraherar information från användar uttryck, som krävs för att fullfil användarens avsikt.The entity extracts information from the user utterance, necessary to fullfil the user's intention. Det finns flera typer av färdiga och anpassade entiteter, var och en med sina egna DTO-modeller (data Transformation Object).There are several types of prebuilt and custom entities, each with their own data transformation object (DTO) models. Vanliga fördefinierade entiteter som ska läggas till i din app är Number, datetimeV2, geographyV2, ordinal.Common prebuilt entities to add to your app include number, datetimeV2, geographyV2, ordinal.

Den här add_entities -metoden skapade en Location enkel entitet med två roller, en Class enkel entitet, en Flight sammansatt entitet och lägger till flera fördefinierade entiteter.This add_entities method created a Location simple entity with two roles, a Class simple entity, a Flight composite entity and adds several prebuilt entities.

Det är viktigt att veta att entiteter inte har marker ATS med ett avsikts syfte.It is important to know that entities are not marked with an intent. De kan och används vanligt vis för många syften.They can and usually do apply to many intents. Endast yttranden är markerade för ett visst, enskilt syfte.Only example user utterances are marked for a specific, single intent.

Skapande metoder för entiteter ingår i ModelOperations -klassen.Creation methods for entities are part of the ModelOperations class. Varje entitetstyp har sin egen DTO-modell (data Transformation Object).Each entity type has its own data transformation object (DTO) model.

def add_entities(app_id, app_version):

    locationEntityId = client.model.add_entity(app_id, app_version, "Location")
    print("locationEntityId {} added.".format(locationEntityId)) 

    originRoleId = client.model.create_entity_role(app_id, app_version, locationEntityId, "Origin")
    print("originRoleId {} added.".format(originRoleId)) 

    destinationRoleId = client.model.create_entity_role(app_id, app_version, locationEntityId, "Destination")
    print("destinationRoleId {} added.".format(destinationRoleId)) 

    classEntityId = client.model.add_entity(app_id, app_version, name="Class")
    print("classEntityId {} added.".format(classEntityId)) 

    client.model.add_prebuilt(app_id, app_version, prebuilt_extractor_names=["number", "datetimeV2", "geographyV2", "ordinal"])

    compositeEntityId = client.model.add_composite_entity(app_id, app_version, name="Flight",
                                      children=["Location", "Class", "number", "datetimeV2", "geographyV2", "ordinal"])
    print("compositeEntityId {} added.".format(compositeEntityId)) 

Lägg till exempel uttryck till avsiktAdd example utterance to intent

Appen behöver exempel på yttranden för att kunna fastställa en uttryck för avsikt och extrahering av entiteter.In order to determine an utterance's intention and extract entities, the app needs examples of utterances. Exemplen måste vara riktade mot en viss, enskild avsikt och ska markera alla anpassade entiteter.The examples need to target a specific, single intent and should mark all custom entities. Fördefinierade entiteter behöver inte markeras.Prebuilt entities do not need to be marked.

Lägg till exempel yttranden genom att skapa en lista över ExampleLabelObject -objekt, ett objekt för varje exempel uttryck.Add example utterances by creating a list of ExampleLabelObject objects, one object for each example utterance. Varje exempel bör markera alla entiteter med en ord lista med namn/värde-par för enhets namn och enhets värde.Each example should mark all entities with a dictionary of name/value pairs of entity name and entity value. Enhet svärdet bör vara exakt så som det visas i texten i exemplet uttryck.The entity value should be exactly as it appears in the text of the example utterance.

Anropa exempel. batch med app-ID, VERSIONS-ID och listan med exempel.Call examples.batch with the app ID, version ID, and the list of examples. Anropet svarar med en lista över resultat.The call responds with a list of results. Du måste kontrol lera varje exempels resultat för att se till att det har lagts till i modellen.You need to check each example's result to make sure it was successfully added to the model.

def add_utterances(app_id, app_version):
    # Now define the utterances
    utterances = [create_utterance("FindFlights", "find flights in economy to Madrid",
                            ("Flight", "economy to Madrid"),
                            ("Location", "Madrid"),
                            ("Class", "economy")),

                  create_utterance("FindFlights", "find flights to London in first class",
                            ("Flight", "London in first class"),
                            ("Location", "London"),
                            ("Class", "first")),

                  create_utterance("FindFlights", "find flights from seattle to London in first class",
                            ("Flight", "flights from seattle to London in first class"),
                            ("Location", "London"),
                            ("Location", "Seattle"),
                            ("Class", "first"))]

    # Add the utterances in batch. You may add any number of example utterances
    # for any number of intents in one call.
    client.examples.batch(app_id, app_version, utterances)
    print("{} example utterance(s) added.".format(len(utterances)))

Träna appenTrain the app

När modellen har skapats måste LUIS-appen tränas för den här versionen av modellen.Once the model is created, the LUIS app needs to be trained for this version of the model. En utbildad modell kan användas i en behållareeller publiceras på mellanlagrings-eller produkt platserna.A trained model can be used in a container, or published to the staging or product slots.

Metoden Train. train_version kräver app-ID och VERSIONS-ID.The train.train_version method needs the app ID and the version ID.

En mycket liten modell, till exempel den här snabb starten visar, kommer att träna mycket snabbt.A very small model, such as this quickstart shows, will train very quickly. Utbildning appen måste innehålla ett avsöknings anrop till get_Status -metoden för att fastställa när en utbildning har genomförts för program på produktions nivå.For production-level applications, training the app should include a polling call to the get_status method to determine when or if the training succeeded. Svaret är en lista över ModelTrainingInfo -objekt med separat status för varje objekt.The response is a list of ModelTrainingInfo objects with a separate status for each object. Alla objekt måste lyckas för att träningen ska anses vara slutförd.All objects must be successful for the training to be considered complete.

def train_app(app_id, app_version):
    response = client.train.train_version(app_id, app_version)
    waiting = True
    while waiting:
        info = client.train.get_status(app_id, app_version)

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

Publicera en Language Understanding appPublish a Language Understanding app

Publicera LUIS-appen med metoden app. Publish .Publish the LUIS app using the app.publish method. Detta publicerar den aktuella utbildade versionen till den angivna platsen vid slut punkten.This publishes the current trained version to the specified slot at the endpoint. Klient programmet använder den här slut punkten för att skicka användarens yttranden för förutsägelse av avsikt och extrahering av enheter.Your client application uses this endpoint to send user utterances for prediction of intent and entity extraction.

def publish_app(app_id, app_version):
    response = client.apps.publish(app_id, app_version, is_staging=True)
    print("Application published. Endpoint URL: " + response.endpoint_url)

Köra programmetRun the application

Kör programmet med kommandot python på snabb starts filen.Run the application with the python command on your quickstart file.

python quickstart-file.py

Rensa resurserClean up resources

Om du vill rensa och ta bort en Cognitive Services prenumeration kan du ta bort resursen eller resurs gruppen.If you want to clean up and remove a Cognitive Services subscription, you can delete the resource or resource group. Om du tar bort resurs gruppen raderas även andra resurser som är kopplade till den.Deleting the resource group also deletes any other resources associated with it.

Nästa stegNext steps