Conversational Language Understanding (CLU), ein Feature von Azure KI Language, ist die aktualisierte Version von LUIS.
Weitere Informationen zur Unterstützung von Language Understanding im Bot Framework SDK finden Sie unter Natürliches Sprachverständnis.
Die Fähigkeit zu verstehen, was Ihr Benutzer in einer Konversation und im Kontext meint, kann eine schwierige Aufgabe sein, Ihrem Bot aber ein natürlicheres Sprachgefühl verleihen. Language Understanding (LUIS) ist ein cloudbasierter API-Dienst, der Ihnen genau dies ermöglicht, sodass Ihr Bot die Absicht von Benutzernachrichten bestimmen, mehr natürliche Sprache von Ihrem Benutzer erkennen und den Konversationsablauf besser steuern kann.
In diesem Thema wird Schritt für Schritt erläutert, wie Sie LUIS einer Anwendung zur Flugbuchung hinzufügen, um verschiedene Absichten und Entitäten zu erkennen, die in der Eingabe des Benutzers enthalten sind.
Hinweis
Die JavaScript-, C#- und Python-SDKs für Bot Framework werden weiterhin unterstützt, das Java-SDK wird jedoch eingestellt und der langfristige Support endet im November 2023.
Bestehende Bots, die mit dem Java SDK erstellt wurden, werden weiterhin funktionieren.
Dieses Core Bot-Beispiel zur Sprachgenerierung veranschaulicht eine Flugbuchungsanwendung. Im Beispiel wird ein LUIS-Dienst verwendet, um die Benutzereingabe zu erkennen und die erkannte LUIS-Absicht mit der höchsten Bewertung zurückzugeben.
Das Sprachmodell enthält drei Absichten: Book Flight, Cancel und None. LUIS verwendet diese Absichten, um zu verstehen, was der Benutzer gemeint hat, als er eine Nachricht an den Bot gesendet hat. Das Sprachmodell definiert außerdem Entitäten, die LUIS aus der Eingabe des Benutzers extrahieren kann, z. B. den Start- oder den Zielflughafen.
Nach jeder Verarbeitung der Benutzereingabe speichert DialogBot den aktuellen Zustand von UserState und ConversationState. Nachdem alle erforderlichen Informationen erfasst wurden, erstellt das Codebeispiel eine Demobuchungsreservierung für einen Flug. In diesem Artikel werden die LUIS-Aspekte des Beispiels behandelt. Der allgemeine Flow für das Beispiel ist jedoch:
OnMembersAddedAsync wird aufgerufen, wenn ein neuer Benutzer verbunden und eine Begrüßungskarte angezeigt wird.
OnMessageActivityAsync wird für jede empfangene Benutzereingabe aufgerufen.
Das OnMessageActivityAsync-Modul führt den entsprechenden Dialog über die Run-Dialogerweiterungsmethode aus. Der Hauptdialog ruft das LUIS-Hilfsprogramm auf, um die Benutzerabsicht mit der höchsten Bewertung zu ermitteln. Wenn für die Benutzereingabe als am höchsten bewertete Absicht „BookFlight“ (Flug buchen) zurückgegeben wird, fügt das Hilfsprogramm die Informationen des Benutzers ein, der von LUIS zurückgegeben wurde. Anschließend wird vom Hauptdialog der BookingDialog gestartet, mit dem zusätzliche Informationen nach Bedarf vom Benutzer abgerufen werden, z. B.:
Origin: Startort
TravelDate: Datum, für das der Flug gebucht werden soll
Destination: Zielort
Nach jeder Verarbeitung der Benutzereingabe speichert dialogBot den aktuellen Zustand von userState und conversationState. Nachdem alle erforderlichen Informationen erfasst wurden, erstellt das Codebeispiel eine Demobuchungsreservierung für einen Flug. In diesem Artikel werden die LUIS-Aspekte des Beispiels behandelt. Der allgemeine Flow für das Beispiel ist jedoch:
onMembersAdded wird aufgerufen, wenn ein neuer Benutzer verbunden und eine Begrüßungskarte angezeigt wird.
OnMessage wird für jede empfangene Benutzereingabe aufgerufen.
Das onMessage-Modul führt das mainDialog-Element aus, mit dem die Benutzereingabe erfasst wird.
Der Hauptdialog ruft das LUIS-Hilfsprogramm FlightBookingRecognizer auf, um die Benutzerabsicht mit der höchsten Bewertung zu ermitteln. Wenn für die Benutzereingabe als am höchsten bewertete Absicht „BookFlight“ (Flug buchen) zurückgegeben wird, fügt das Hilfsprogramm die Informationen des Benutzers ein, der von LUIS zurückgegeben wurde.
Nach der Antwort werden von mainDialog die von LUIS zurückgegebenen Informationen zum Benutzer gespeichert, und bookingDialog wird gestartet. bookingDialog erfasst bei Bedarf zusätzliche Informationen vom Benutzer, beispielsweise:
destination: Zielort
origin: Startort
travelDate: Datum, für das der Flug gebucht werden soll
Nach jeder Verarbeitung der Benutzereingabe speichert DialogBot den aktuellen Zustand von UserState und ConversationState.
Nachdem alle erforderlichen Informationen erfasst wurden, erstellt das Codebeispiel eine Demobuchungsreservierung für einen Flug.
In diesem Artikel werden die LUIS-Aspekte des Beispiels behandelt. Der allgemeine Flow für das Beispiel ist jedoch:
onMembersAdded wird aufgerufen, wenn ein neuer Benutzer verbunden und eine Begrüßungskarte angezeigt wird.
onMessageActivity wird für jede empfangene Benutzereingabe aufgerufen.
Das onMessageActivity-Modul führt den entsprechenden Dialog über die run-Dialogerweiterungsmethode aus. Der Hauptdialog ruft das LUIS-Hilfsprogramm auf, um die Benutzerabsicht mit der höchsten Bewertung zu ermitteln. Wenn für die Benutzereingabe als am höchsten bewertete Absicht „BookFlight“ (Flug buchen) zurückgegeben wird, fügt das Hilfsprogramm die Informationen des Benutzers ein, der von LUIS zurückgegeben wurde. Anschließend wird vom Hauptdialog der BookingDialog gestartet, mit dem zusätzliche Informationen nach Bedarf vom Benutzer abgerufen werden, z. B.:
Origin: Startort
TravelDate: Datum, für das der Flug gebucht werden soll
Destination: Zielort
Nach jeder Verarbeitung der Benutzereingabe speichert DialogBot den aktuellen Zustand von user_state und conversation_state. Nachdem alle erforderlichen Informationen erfasst wurden, erstellt das Codebeispiel eine Demobuchungsreservierung für einen Flug. In diesem Artikel werden die LUIS-Aspekte des Beispiels behandelt. Der allgemeine Flow für das Beispiel ist jedoch:
on_members_added_activity wird aufgerufen, wenn ein neuer Benutzer verbunden und eine Begrüßungskarte angezeigt wird.
on_message_activity wird für jede empfangene Benutzereingabe aufgerufen.
Das on_message_activity-Modul führt den entsprechenden Dialog über die run_dialog-Dialogerweiterungsmethode aus. Der Hauptdialog ruft dann LuisHelper auf, um die Benutzerabsicht mit der höchsten Bewertung zu ermitteln. Wenn für die Benutzereingabe als am höchsten bewertete Absicht „BookFlight“ (Flug buchen) zurückgegeben wird, fügt die Hilfsfunktion die Informationen des Benutzers ein, der von LUIS zurückgegeben wurde. Anschließend wird vom Hauptdialog der BookingDialog gestartet, mit dem zusätzliche Informationen nach Bedarf vom Benutzer abgerufen werden, z. B.:
destination: Zielort
origin: Startort
travel_date: Datum, für das der Flug gebucht werden soll
Wählen Sie auf der Seite Konversationsanwendungen in LUIS die Option Importieren und dann Als JSON importieren aus.
Im Dialogfeld Neue App importieren:
Wählen Sie im Ordner CognitiveModels des Beispiels die Datei FlightBooking.json aus.
Geben Sie FlightBooking als optionalen Namen der App ein und klicken Sie auf Fertig.
Auf der Website können die Dialoge Wie man eine effektive LUIS-App erstellt und Aktualisieren Sie Ihre zusammengesetzten Einheiten angezeigt werden. Sie können diese Dialoge schließen und fortfahren.
Trainieren Sie Ihre App und veröffentlichen Sie ihre App dann in der Produktionsumgebung.
Weitere Informationen finden Sie in der LUIS-Dokumentation zum Trainieren und Veröffentlichen einer App.
Gründe für die Verwendung von Entitäten
LUIS-Entitäten ermöglichen Ihrem Bot, Ereignisse über Standardabsichten hinaus zu verstehen. Auf diese Weise können Sie zusätzliche Informationen von Benutzern sammeln, damit Ihr Bot Fragen stellen und intelligenter antworten kann. Neben den Definitionen für die drei LUIS-Absichten „Book Flight“ (Flug buchen), „Cancel“ (Abbrechen) und „None“ (Keine) enthält die Datei „FlightBooking.json“ auch eine Gruppe von Entitäten, z. B. „From.Airport“ und „To.Airport“. Mithilfe dieser Entitäten kann LUIS zusätzliche Informationen in der ursprünglichen Eingabe des Benutzers erkennen und zurückgeben, wenn der Benutzer eine neue Buchung anfordert.
Abrufen von Werten zum Herstellen einer Verbindung mit Ihrer LUIS-App
Nachdem Ihre LUIS-App veröffentlicht wurde, können Sie von Ihrem Bot aus darauf zugreifen. Sie müssen sich mehrere Werte notieren, um von Ihrem Bot aus auf Ihre LUIS-App zugreifen zu können. Sie können diese Informationen mit dem LUIS-Portal abrufen.
Anwendungsinformationen vom Portal LUIS.ai abrufen
In der Einstellungsdatei (appsettings.json, .env oder config.py) werden alle Dienstverweise an einer Stelle zusammengefasst. Die von Ihnen abgerufenen Informationen werden dieser Datei im nächsten Abschnitt hinzugefügt.
Wählen Sie Ihre veröffentlichte LUIS-App unter luis.ai aus.
Wählen Sie bei geöffneter veröffentlichter LUIS-App die Registerkarte VERWALTEN.
Wählen Sie auf der linken Seite die Registerkarte Einstellungen und notieren Sie sich den Wert, der unter Anwendungs-ID angezeigt wird, als <YOUR_APP_ID>.
Wählen Sie Azure-Ressourcen und dann Vorhersageressource aus. Notieren Sie sich die folgenden Werte: Region als <YOUR_REGION> und Primärschlüssel als <YOUR_AUTHORING_KEY>.
Alternativ können Sie die Region und den Primärschlüssel für Ihre Autorenressource verwenden.
Fügen Sie in der appsettings.json-Datei die erforderlichen Informationen für den Zugriff auf Ihre LUIS-App hinzu (einschließlich Anwendungs-ID, Erstellungsschlüssel und Region). Im vorherigen Schritt haben Sie diese Werte aus Ihrer veröffentlichten LUIS-App abgerufen. Der API-Hostname sollte im Format <your region>.api.cognitive.microsoft.com angegeben werden.
Fügen Sie in der .env-Datei die erforderlichen Informationen für den Zugriff auf Ihre LUIS-App hinzu (einschließlich Anwendungs-ID, Erstellungsschlüssel und Region). Im vorherigen Schritt haben Sie diese Werte aus Ihrer veröffentlichten LUIS-App abgerufen. Der API-Hostname sollte im Format <your region>.api.cognitive.microsoft.com angegeben werden.
Fügen Sie in der application.properties-Datei die erforderlichen Informationen für den Zugriff auf Ihre LUIS-App hinzu (einschließlich Anwendungs-ID, Erstellungsschlüssel und Region). Im vorherigen Schritt haben Sie diese Werte aus Ihrer veröffentlichten LUIS-App abgerufen. Der API-Hostname sollte im Format <your region>.api.cognitive.microsoft.com angegeben werden.
Fügen Sie in der config.py-Datei die erforderlichen Informationen für den Zugriff auf Ihre LUIS-App hinzu (einschließlich Anwendungs-ID, Erstellungsschlüssel und Region). Im vorherigen Schritt haben Sie diese Werte aus Ihrer veröffentlichten LUIS-App abgerufen. Der API-Hostname sollte im Format <your region>.api.cognitive.microsoft.com angegeben werden.
Stellen Sie sicher, dass das NuGet-Paket Microsoft.Bot.Builder.AI.Luis für Ihr Projekt installiert ist.
Zum Herstellen einer Verbindung mit dem LUIS-Dienst pullt der Bot die Informationen, die Sie in der Datei „appsetting.json“ hinzugefügt haben. Die FlightBookingRecognizer-Klasse enthält Code mit Ihren Einstellungen aus der Datei „appsetting.json“ und fragt den LUIS-Dienst durch das Aufrufen der RecognizeAsync-Methode ab.
FlightBookingRecognizer.cs
public class FlightBookingRecognizer : IRecognizer
{
private readonly LuisRecognizer _recognizer;
public FlightBookingRecognizer(IConfiguration configuration)
{
var luisIsConfigured = !string.IsNullOrEmpty(configuration["LuisAppId"]) && !string.IsNullOrEmpty(configuration["LuisAPIKey"]) && !string.IsNullOrEmpty(configuration["LuisAPIHostName"]);
if (luisIsConfigured)
{
var luisApplication = new LuisApplication(
configuration["LuisAppId"],
configuration["LuisAPIKey"],
"https://" + configuration["LuisAPIHostName"]);
// Set the recognizer options depending on which endpoint version you want to use.
// More details can be found in https://docs.microsoft.com/en-gb/azure/cognitive-services/luis/luis-migration-api-v3
var recognizerOptions = new LuisRecognizerOptionsV3(luisApplication)
{
PredictionOptions = new Bot.Builder.AI.LuisV3.LuisPredictionOptions
{
IncludeInstanceData = true,
}
};
_recognizer = new LuisRecognizer(recognizerOptions);
}
}
// Returns true if luis is configured in the appsettings.json and initialized.
public virtual bool IsConfigured => _recognizer != null;
public virtual async Task<RecognizerResult> RecognizeAsync(ITurnContext turnContext, CancellationToken cancellationToken)
=> await _recognizer.RecognizeAsync(turnContext, cancellationToken);
public virtual async Task<T> RecognizeAsync<T>(ITurnContext turnContext, CancellationToken cancellationToken)
where T : IRecognizerConvert, new()
=> await _recognizer.RecognizeAsync<T>(turnContext, cancellationToken);
}
Die Datei FlightBookingEx.cs enthält die Logik zum Extrahieren der Werte von From, To und TravelDate. Die verwendete partielle Klasse FlightBooking.cs wird erweitert, um LUIS-Ergebnisse beim Aufrufen von FlightBookingRecognizer.RecognizeAsync<FlightBooking> aus MainDialog.cs zu speichern.
CognitiveModels\FlightBookingEx.cs
// Extends the partial FlightBooking class with methods and properties that simplify accessing entities in the luis results
public partial class FlightBooking
{
public (string From, string Airport) FromEntities
{
get
{
var fromValue = Entities?._instance?.From?.FirstOrDefault()?.Text;
var fromAirportValue = Entities?.From?.FirstOrDefault()?.Airport?.FirstOrDefault()?.FirstOrDefault();
return (fromValue, fromAirportValue);
}
}
public (string To, string Airport) ToEntities
{
get
{
var toValue = Entities?._instance?.To?.FirstOrDefault()?.Text;
var toAirportValue = Entities?.To?.FirstOrDefault()?.Airport?.FirstOrDefault()?.FirstOrDefault();
return (toValue, toAirportValue);
}
}
// This value will be a TIMEX. And we are only interested in a Date so grab the first result and drop the Time part.
// TIMEX is a format that represents DateTime expressions that include some ambiguity. e.g. missing a Year.
public string TravelDate
=> Entities.datetime?.FirstOrDefault()?.Expressions.FirstOrDefault()?.Split('T')[0];
}
Ihr muss Projekt das npm-Paket botbuilder-ai installieren, um LUIS verwenden zu können.
Zum Herstellen einer Verbindung mit dem LUIS-Dienst nutzt der Bot die Informationen, die Sie in der .env-Datei hinzugefügt haben. Die flightBookingRecognizer.js-Klasse enthält den Code, der die Einstellungen aus der .env-Datei importiert und den LUIS-Dienst durch Aufrufen der recognize()-Methode abfragt.
dialogs/flightBookingRecognizer.js
class FlightBookingRecognizer {
constructor(config) {
const luisIsConfigured = config && config.applicationId && config.endpointKey && config.endpoint;
if (luisIsConfigured) {
// Set the recognizer options depending on which endpoint version you want to use e.g v2 or v3.
// More details can be found in https://docs.microsoft.com/en-gb/azure/cognitive-services/luis/luis-migration-api-v3
const recognizerOptions = {
apiVersion: 'v3'
};
this.recognizer = new LuisRecognizer(config, recognizerOptions);
}
}
get isConfigured() {
return (this.recognizer !== undefined);
}
/**
* Returns an object with preformatted LUIS results for the bot's dialogs to consume.
* @param {TurnContext} context
*/
async executeLuisQuery(context) {
return await this.recognizer.recognize(context);
}
getFromEntities(result) {
let fromValue, fromAirportValue;
if (result.entities.$instance.From) {
fromValue = result.entities.$instance.From[0].text;
}
if (fromValue && result.entities.From[0].Airport) {
fromAirportValue = result.entities.From[0].Airport[0][0];
}
return { from: fromValue, airport: fromAirportValue };
}
getToEntities(result) {
let toValue, toAirportValue;
if (result.entities.$instance.To) {
toValue = result.entities.$instance.To[0].text;
}
if (toValue && result.entities.To[0].Airport) {
toAirportValue = result.entities.To[0].Airport[0][0];
}
return { to: toValue, airport: toAirportValue };
}
/**
* This value will be a TIMEX. And we are only interested in a Date so grab the first result and drop the Time part.
* TIMEX is a format that represents DateTime expressions that include some ambiguity. e.g. missing a Year.
*/
getTravelDate(result) {
const datetimeEntity = result.entities.datetime;
if (!datetimeEntity || !datetimeEntity[0]) return undefined;
const timex = datetimeEntity[0].timex;
if (!timex || !timex[0]) return undefined;
const datetime = timex[0].split('T')[0];
return datetime;
}
}
Die Logik zum Extrahieren von „From“, „To“ und „TravelDate“ wird in flightBookingRecognizer.js in Form von Hilfsmethoden implementiert. Diese Methoden werden verwendet, nachdem flightBookingRecognizer.executeLuisQuery() aus mainDialog.js aufgerufen wurde.
Stellen Sie sicher, dass das Paket com.microsoft.bot.bot-ai-luis-v3 zur Datei „pom.xml“ hinzugefügt wird.
Zum Herstellen einer Verbindung mit dem LUIS-Dienst pullt der Bot die Informationen, die Sie in der Datei „application.properties“ hinzugefügt haben. Die FlightBookingRecognizer-Klasse enthält Code mit Ihren Einstellungen aus der Datei „application.properties“ und fragt den LUIS-Dienst durch das Aufrufen der recognize-Methode ab.
FlightBookingRecognizer.java
/**
* The constructor of the FlightBookingRecognizer class.
*
* @param configuration The Configuration object to use.
*/
public FlightBookingRecognizer(Configuration configuration) {
Boolean luisIsConfigured = StringUtils.isNotBlank(configuration.getProperty("LuisAppId"))
&& StringUtils.isNotBlank(configuration.getProperty("LuisAPIKey"))
&& StringUtils.isNotBlank(configuration.getProperty("LuisAPIHostName"));
if (luisIsConfigured) {
LuisApplication luisApplication = new LuisApplication(
configuration.getProperty("LuisAppId"),
configuration.getProperty("LuisAPIKey"),
String.format("https://%s", configuration.getProperty("LuisAPIHostName"))
);
// Set the recognizer options depending on which endpoint version you want to use.
// More details can be found in
// https://docs.microsoft.com/en-gb/azure/cognitive-services/luis/luis-migration-api-v3
LuisRecognizerOptionsV3 recognizerOptions = new LuisRecognizerOptionsV3(luisApplication);
recognizerOptions.setIncludeInstanceData(true);
this.recognizer = new LuisRecognizer(recognizerOptions);
}
}
/**
* Runs an utterance through a recognizer and returns a generic recognizer result.
*
* @param turnContext Turn context.
* @return Analysis of utterance.
*/
@Override
public CompletableFuture<RecognizerResult> recognize(TurnContext turnContext) {
return this.recognizer.recognize(turnContext);
}
Der FlightBookingRecognizer.cs enthält die Logik zum Extrahieren von From, To und TravelDate und wird vom MainDialog.java aufgerufen, um die Ergebnisse des Luis-Abfrageergebnisses zu decodieren.
FlightBookingRecognizer.java
/**
* Gets the From data from the entities which is part of the result.
*
* @param result The recognizer result.
* @return The object node representing the From data.
*/
public ObjectNode getFromEntities(RecognizerResult result) {
String fromValue = "", fromAirportValue = "";
if (result.getEntities().get("$instance").get("From") != null) {
fromValue = result.getEntities().get("$instance").get("From").get(0).get("text")
.asText();
}
if (!fromValue.isEmpty()
&& result.getEntities().get("From").get(0).get("Airport") != null) {
fromAirportValue = result.getEntities().get("From").get(0).get("Airport").get(0).get(0)
.asText();
}
ObjectMapper mapper = new ObjectMapper().findAndRegisterModules();
ObjectNode entitiesNode = mapper.createObjectNode();
entitiesNode.put("from", fromValue);
entitiesNode.put("airport", fromAirportValue);
return entitiesNode;
}
/**
* Gets the To data from the entities which is part of the result.
*
* @param result The recognizer result.
* @return The object node representing the To data.
*/
public ObjectNode getToEntities(RecognizerResult result) {
String toValue = "", toAirportValue = "";
if (result.getEntities().get("$instance").get("To") != null) {
toValue = result.getEntities().get("$instance").get("To").get(0).get("text").asText();
}
if (!toValue.isEmpty() && result.getEntities().get("To").get(0).get("Airport") != null) {
toAirportValue = result.getEntities().get("To").get(0).get("Airport").get(0).get(0)
.asText();
}
ObjectMapper mapper = new ObjectMapper().findAndRegisterModules();
ObjectNode entitiesNode = mapper.createObjectNode();
entitiesNode.put("to", toValue);
entitiesNode.put("airport", toAirportValue);
return entitiesNode;
}
/**
* This value will be a TIMEX. And we are only interested in a Date so grab the first result and
* drop the Time part. TIMEX is a format that represents DateTime expressions that include some
* ambiguity. e.g. missing a Year.
*
* @param result A {link RecognizerResult}
* @return The Timex value without the Time model
*/
public String getTravelDate(RecognizerResult result) {
JsonNode datetimeEntity = result.getEntities().get("datetime");
if (datetimeEntity == null || datetimeEntity.get(0) == null) {
return null;
}
JsonNode timex = datetimeEntity.get(0).get("timex");
if (timex == null || timex.get(0) == null) {
return null;
}
String datetime = timex.get(0).asText().split("T")[0];
return datetime;
}
Achten Sie darauf, dass das PyPI-Paket botbuilder-ai für Ihr Projekt installiert ist.
Zum Herstellen einer Verbindung mit dem LUIS-Dienst nutzt der Bot die Informationen, die Sie in der config.py-Datei hinzugefügt haben. Die FlightBookingRecognizer-Klasse enthält den Code, der die Einstellungen aus der config.py-Datei importiert und den LUIS-Dienst durch Aufrufen der recognize()-Methode abfragt.
flight_booking_recognizer.py
class FlightBookingRecognizer(Recognizer):
def __init__(self, configuration: DefaultConfig):
self._recognizer = None
luis_is_configured = (
configuration.LUIS_APP_ID
and configuration.LUIS_API_KEY
and configuration.LUIS_API_HOST_NAME
)
if luis_is_configured:
# Set the recognizer options depending on which endpoint version you want to use e.g v2 or v3.
# More details can be found in https://docs.microsoft.com/azure/cognitive-services/luis/luis-migration-api-v3
luis_application = LuisApplication(
configuration.LUIS_APP_ID,
configuration.LUIS_API_KEY,
"https://" + configuration.LUIS_API_HOST_NAME,
)
self._recognizer = LuisRecognizer(luis_application)
@property
def is_configured(self) -> bool:
# Returns true if luis is configured in the config.py and initialized.
return self._recognizer is not None
async def recognize(self, turn_context: TurnContext) -> RecognizerResult:
return await self._recognizer.recognize(turn_context)
Die Logik zum Extrahieren von From, To und travel_date wird in luis_helper.py in Form von Hilfsmethoden aus der LuisHelper-Klasse implementiert. Diese Methoden werden verwendet, nachdem LuisHelper.execute_luis_query() aus main_dialog.py aufgerufen wurde.
helpers/luis_helper.py
class LuisHelper:
@staticmethod
async def execute_luis_query(
luis_recognizer: LuisRecognizer, turn_context: TurnContext
) -> (Intent, object):
"""
Returns an object with preformatted LUIS results for the bot's dialogs to consume.
"""
result = None
intent = None
try:
recognizer_result = await luis_recognizer.recognize(turn_context)
intent = (
sorted(
recognizer_result.intents,
key=recognizer_result.intents.get,
reverse=True,
)[:1][0]
if recognizer_result.intents
else None
)
if intent == Intent.BOOK_FLIGHT.value:
result = BookingDetails()
# We need to get the result from the LUIS JSON which at every level returns an array.
to_entities = recognizer_result.entities.get("$instance", {}).get(
"To", []
)
if len(to_entities) > 0:
if recognizer_result.entities.get("To", [{"$instance": {}}])[0][
"$instance"
]:
result.destination = to_entities[0]["text"].capitalize()
else:
result.unsupported_airports.append(
to_entities[0]["text"].capitalize()
)
from_entities = recognizer_result.entities.get("$instance", {}).get(
"From", []
)
if len(from_entities) > 0:
if recognizer_result.entities.get("From", [{"$instance": {}}])[0][
"$instance"
]:
result.origin = from_entities[0]["text"].capitalize()
else:
result.unsupported_airports.append(
from_entities[0]["text"].capitalize()
)
# This value will be a TIMEX. And we are only interested in a Date so grab the first result and drop
# the Time part. TIMEX is a format that represents DateTime expressions that include some ambiguity.
# e.g. missing a Year.
date_entities = recognizer_result.entities.get("datetime", [])
if date_entities:
timex = date_entities[0]["timex"]
if timex:
datetime = timex[0].split("T")[0]
result.travel_date = datetime
else:
result.travel_date = None
except Exception as exception:
print(exception)
return intent, result
LUIS ist jetzt für Ihren Bot konfiguriert und verbunden.
Testen des Bots
Laden Sie die aktuelle Version von Bot Framework Emulator herunter, und installieren Sie sie.
Führen Sie das Beispiel lokal auf Ihrem Computer aus. Wenn Sie eine Anleitung benötigen, finden Sie in der README-Datei für das C#-Beispiel, JS-Beispiel oder Python-Beispiel weitere Informationen.
Geben Sie im Emulator eine Nachricht wie „travel to Paris“ oder „going from Paris to Berlin“ ein. Verwenden Sie alle Äußerungen in der Datei „FlightBooking.json“ zum Trainieren der Absicht „Book flight“ (Flug buchen).
Wenn die von LUIS zurückgegebene Absicht mit der höchsten Bewertung zu „Book flight“ (Flug buchen) aufgelöst wird, stellt Ihr Bot weitere Fragen, bis er genügend Informationen zum Erstellen einer Flugbuchung hat. An diesem Punkt werden die vorliegenden Buchungsinformationen an den Benutzer zurückgegeben.
Der Code der Botlogik wird an diesem Punkt zurückgesetzt, und Sie können mit dem Erstellen weiterer Buchungen fortfahren.
Weitere Informationen
Weitere Informationen zu LUIS finden Sie in der LUIS-Dokumentation:
In verschiedenen Teilen des SDK werden separate Entitätsklassen oder Elemente definiert.
Informationen zu den Nachrichtenentitäten finden Sie unter Entitäts- und Aktivitätstypen.
