Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Verwenden Sie Konfidenzwerte für die Sprachtranskription, um die Konversation mit Ihrem Lex V2-Bot zu verbessern

Wenn ein Benutzer eine Sprachäußerung macht, verwendet Amazon Lex V2 die automatische Spracherkennung (ASR), um die Anfrage des Benutzers zu transkribieren, bevor sie interpretiert wird. Standardmäßig verwendet Amazon Lex V2 die wahrscheinlichste Transkription des Audiomaterials für die Interpretation.

In einigen Fällen kann es mehr als eine mögliche Transkription des Audios geben. Beispielsweise könnte ein Benutzer eine Äußerung mit einem mehrdeutigen Ton machen, z. B. „Mein Name ist John“, die als „Mein Name ist Juan“ verstanden werden könnte. In diesem Fall können Sie Techniken zur Begriffsklärung verwenden oder Ihr Fachwissen mit dem Transkriptionsvertrauenswert kombinieren, um festzustellen, welche Transkription in einer Liste von Transkriptionen die richtige ist.

Amazon Lex V2 umfasst die oberste Transkription und bis zu zwei alternative Transkriptionen für Benutzereingaben in der Anfrage an Ihre Lambda-Code-Hook-Funktion. Jede Transkription enthält einen Vertrauenswert, dass es sich um die richtige Transkription handelt. Jede Transkription enthält auch alle Slot-Werte, die aus der Benutzereingabe abgeleitet wurden.

Sie können die Konfidenzwerte zweier Transkriptionen vergleichen, um festzustellen, ob zwischen ihnen Unklarheiten bestehen. Wenn beispielsweise eine Transkription einen Konfidenzwert von 0,95 und die andere einen Konfidenzwert von 0,65 hat, ist die erste Transkription wahrscheinlich korrekt und die Mehrdeutigkeit zwischen ihnen ist gering. Wenn die beiden Transkriptionen Konfidenzwerte von 0,75 und 0,72 haben, ist die Ambiguität zwischen ihnen hoch. Möglicherweise können Sie anhand Ihres Fachwissens zwischen ihnen unterscheiden.

Wenn die abgeleiteten Slot-Werte in zwei Transkripten mit einem Konfidenzwert von 0,75 und 0,72 beispielsweise „John“ und „Juan“ lauten, können Sie die Benutzer in Ihrer Datenbank nach der Existenz dieser Namen abfragen und eine der Transkriptionen entfernen. Wenn „John“ kein Benutzer in Ihrer Datenbank ist und „Juan“ schon, können Sie den Dialogcode-Hook verwenden, um den abgeleiteten Slot-Wert für den Vornamen in „Juan“ zu ändern.

Bei den Konfidenzwerten, die Amazon Lex V2 zurückgibt, handelt es sich um Vergleichswerte. Verlassen Sie sich nicht auf sie als absolute Punktzahl. Die Werte können sich aufgrund von Verbesserungen an Amazon Lex V2 ändern.

Zuverlässigkeitswerte für Audiotranskriptionen sind nur in den Sprachen Englisch (GB) (en_GB) und Englisch (US) (en_US) verfügbar. Konfidenzwerte werden nur für 8 Audioeingänge unterstützt. kHz Für die Audioeingabe aus dem Testfenster auf der Amazon Lex V2-Konsole werden keine Werte für die Transkriptionssicherheit bereitgestellt, da 16 kHz Audioeingänge verwendet werden.

Sie können Konfidenzwerte für mehrere Entwurfsmuster für Konversationen verwenden:

Amazon Lex V2 sendet die folgende JSON Struktur mit bis zu drei Transkriptionen für die Benutzereingabe in Ihre Lambda-Code-Hook-Funktion:

    "transcriptions": [
        {
            "transcription": "string",
            "rawTranscription": "string",
            "transcriptionConfidence": "number",
            },
            "resolvedContext": {
                "intent": "string"
            },
            "resolvedSlots": {
                "string": {
                    "shape": "List",
                    "value": {
                        "originalValue": "string",
                        "resolvedValues": [
                            "string"
                        ]
                    },
                    "values": [
                        {
                            "shape": "Scalar",
                            "value": {
                                "originalValue": "string",
                                "resolvedValues": [
                                    "string"
                                ]
                            }
                        },
                        {
                            "shape": "Scalar",
                            "value": {
                                "originalValue": "string",
                                "resolvedValues": [
                                    "string"
                                ]
                            }
                        }
                    ]
                }
            }
        }
    ]
     

Die JSON Struktur enthält den Transkriptionstext, die Absicht, die für die Äußerung aufgelöst wurde, und Werte für alle in der Äußerung erkannten Slots. Bei Texteingaben durch den Benutzer enthalten die Transkriptionen ein einzelnes Transkript mit einem Konfidenzwert von 1,0.

Der Inhalt der Transkripte hängt von der Wendung der Konversation und der erkannten Absicht ab.

Für die erste Runde, die Absichtserkennung, bestimmt Amazon Lex V2 die drei wichtigsten Transkriptionen. Für die oberste Transkription werden die Absicht und alle abgeleiteten Slot-Werte in der Transkription zurückgegeben.

Bei aufeinanderfolgenden Runden (Slot-Exicitation) hängen die Ergebnisse wie folgt von der abgeleiteten Absicht für jede der Transkriptionen ab.

Sitzungsverwaltung

Um die Absicht zu ändern, die Amazon Lex V2 in einer Konversation mit dem Benutzer verwendet, verwenden Sie die Antwort Ihrer Dialogcode-Hook-Lambda-Funktion. Oder Sie können die Sitzungsverwaltung APIs in Ihrer benutzerdefinierten Anwendung verwenden.

Verwenden einer Lambda-Funktion mit Ihrem Lex V2-Bot

Wenn Sie eine Lambda-Funktion verwenden, ruft Amazon Lex V2 sie mit einer JSON Struktur auf, die die Eingabe für die Funktion enthält. Die JSON Struktur enthält ein Feld namenstranscriptions, das die möglichen Transkriptionen enthält, die Amazon Lex V2 für die Äußerung bestimmt hat. Das transcriptions Feld enthält ein bis drei mögliche Transkriptionen mit jeweils einem Konfidenzwert.

Um die Absicht aus einer alternativen Transkription zu verwenden, geben Sie sie in der Dialogaktion ConfirmIntent oder in der ElicitSlot Dialogaktion in Ihrer Lambda-Funktion an. Um einen Slot-Wert aus einer alternativen Transkription zu verwenden, legen Sie den Wert in das intent Feld in Ihrer Lambda-Funktionsantwort fest. Weitere Informationen finden Sie unter Integrieren eines AWS Lambda Funktion in deinen Bot.

Beispielcode mit Lambda mit Lex V2

Das folgende Codebeispiel ist eine Python-Lambda-Funktion, die Audiotranskriptionen verwendet, um das Konversationserlebnis für den Benutzer zu verbessern.

Um den Beispielcode verwenden zu können, benötigen Sie:

import time
import os
import logging

logger = logging.getLogger()
logger.setLevel(logging.DEBUG)


# --- Helpers that build all of the responses ---

def elicit_slot(session_attributes, intent_request, slots, slot_to_elicit, message):
    return {
        'sessionState': {
            'dialogAction': {
                'type': 'ElicitSlot',
                'slotToElicit': slot_to_elicit
            },
            'intent': {
                'name': intent_request['sessionState']['intent']['name'],
                'slots': slots,
                'state': 'InProgress'
            },
            'sessionAttributes': session_attributes,
            'originatingRequestId': 'e3ab4d42-fb5f-4cc3-bb78-caaf6fc7cccd'
        },
        'sessionId': intent_request['sessionId'],
        'messages': [message],
        'requestAttributes': intent_request['requestAttributes'] if 'requestAttributes' in intent_request else None
    }


def close(intent_request, session_attributes, fulfillment_state, message):
    intent_request['sessionState']['intent']['state'] = fulfillment_state
    return {
        'sessionState': {
            'sessionAttributes': session_attributes,
            'dialogAction': {
                'type': 'Close'
            },
            'intent': intent_request['sessionState']['intent'],
            'originatingRequestId': '3ab4d42-fb5f-4cc3-bb78-caaf6fc7cccd'
        },
        'messages': [message],
        'sessionId': intent_request['sessionId'],
        'requestAttributes': intent_request['requestAttributes'] if 'requestAttributes' in intent_request else None
    }


def delegate(intent_request, session_attributes):
    return {
        'sessionState': {
            'dialogAction': {
                'type': 'Delegate'
            },
            'intent': intent_request['sessionState']['intent'],
            'sessionAttributes': session_attributes,
            'originatingRequestId': 'abc'
        },
        'sessionId': intent_request['sessionId'],
        'requestAttributes': intent_request['requestAttributes'] if 'requestAttributes' in intent_request else None
    }


def get_session_attributes(intent_request):
    sessionState = intent_request['sessionState']
    if 'sessionAttributes' in sessionState:
        return sessionState['sessionAttributes']

    return {}


def get_slots(intent_request):
    return intent_request['sessionState']['intent']['slots']


""" --- Functions that control the behavior of the bot --- """


def order_birth_stone(intent_request):
    """
    Performs dialog management and fulfillment for ordering a birth stone.
    Beyond fulfillment, the implementation for this intent demonstrates the following:
    1) Use of N best transcriptions to re prompt user when confidence for top transcript is below a threshold
    2) Overrides resolved slot for birth month from a known fixed list if the top transcript
    is not accurate.
    """

    transcriptions = intent_request['transcriptions']

    if intent_request['invocationSource'] == 'DialogCodeHook':
        # Disambiguate if there are multiple transcriptions and the top transcription
        # confidence is below a threshold (0.8 here)
        if len(transcriptions) > 1 and transcriptions[0]['transcriptionConfidence'] < 0.8:
            if transcriptions[0]['resolvedSlots'] is not {} and 'Name' in transcriptions[0]['resolvedSlots'] and \
                    transcriptions[0]['resolvedSlots']['Name'] is not None:
                return prompt_for_name(intent_request)
            elif transcriptions[0]['resolvedSlots'] is not {} and 'BirthMonth' in transcriptions[0]['resolvedSlots'] and \
                    transcriptions[0]['resolvedSlots']['BirthMonth'] is not None:
                return validate_month(intent_request)

    return continue_conversation(intent_request)


def prompt_for_name(intent_request):
    """
    If the confidence for the name is not high enough, re prompt the user with the recognized names
    so it can be confirmed.
    """
    resolved_names = []
    for transcription in intent_request['transcriptions']:
        if transcription['resolvedSlots'] is not {} and 'Name' in transcription['resolvedSlots'] and \
                transcription['resolvedSlots']['Name'] is not None:
            resolved_names.append(transcription['resolvedSlots']['Name']['value']['originalValue'])
    if len(resolved_names) > 1:
        session_attributes = get_session_attributes(intent_request)
        slots = get_slots(intent_request)
        return elicit_slot(session_attributes, intent_request, slots, 'Name',
                           {'contentType': 'PlainText',
                            'content': 'Sorry, did you say your name is {} ?'.format(" or ".join(resolved_names))})
    else:
        return continue_conversation(intent_request)


def validate_month(intent_request):
    """
    Validate month from an expected list, if not valid looks for other transcriptions and to see if the month
    recognized there has an expected value. If there is, replace with that and if not continue conversation.
    """

    expected_months = ['january', 'february', 'march']
    resolved_months = []
    for transcription in intent_request['transcriptions']:
        if transcription['resolvedSlots'] is not {} and 'BirthMonth' in transcription['resolvedSlots'] and \
                transcription['resolvedSlots']['BirthMonth'] is not None:
            resolved_months.append(transcription['resolvedSlots']['BirthMonth']['value']['originalValue'])

    for resolved_month in resolved_months:
        if resolved_month in expected_months:
            intent_request['sessionState']['intent']['slots']['BirthMonth']['resolvedValues'] = [resolved_month]
            break

    return continue_conversation(intent_request)


def continue_conversation(event):
    session_attributes = get_session_attributes(event)

    if event["invocationSource"] == "DialogCodeHook":
        return delegate(event, session_attributes)


# --- Intents ---


def dispatch(intent_request):
    """
    Called when the user specifies an intent for this bot.
    """

    logger.debug('dispatch sessionId={}, intentName={}'.format(intent_request['sessionId'],
                                                               intent_request['sessionState']['intent']['name']))

    intent_name = intent_request['sessionState']['intent']['name']

    # Dispatch to your bot's intent handlers
    if intent_name == 'OrderBirthStone':
        return order_birth_stone(intent_request)

    raise Exception('Intent with name ' + intent_name + ' not supported')


# --- Main handler ---


def lambda_handler(event, context):
    """
    Route the incoming request based on intent.
    The JSON body of the request is provided in the event slot.

    """
    # By default, treat the user request as coming from the America/New_York time zone.
    os.environ['TZ'] = 'America/New_York'
    time.tzset()
    logger.debug('event={}'.format(event))

    return dispatch(event)

Verwenden Sie die SitzungsverwaltungAPI, um eine andere Absicht oder einen anderen Slot-Wert auszuwählen

Um eine andere Absicht als die aktuelle Absicht zu verwenden, verwenden Sie die PutSessionOperation. Wenn Sie beispielsweise entscheiden, dass die erste Alternative der von Amazon Lex V2 ausgewählten Absicht vorzuziehen ist, können Sie den PutSession Vorgang verwenden, um Absichten zu ändern. Auf diese Weise ist die nächste Absicht, mit der der Benutzer interagiert, die, die Sie ausgewählt haben.

Sie können den PutSession Vorgang auch verwenden, um den Slot-Wert in der intent Struktur zu ändern, um einen Wert aus einer alternativen Transkription zu verwenden.

Weitere Informationen finden Sie unter Grundlegendes zu Amazon Lex V2-Bot-Sitzungen.