Capture de valeurs de créneaux avec des styles d'orthographe

Amazon Lex V2 fournit des emplacements intégrés pour capturer des informations spécifiques à l'utilisateur telles que le prénom, le nom de famille, l'adresse e-mail ou les identifiants alphanumériques. Par exemple, vous pouvez utiliser le AMAZON.LastName slot pour capturer des noms de famille tels que « Jackson » ou « Garcia ». Cependant, Amazon Lex V2 peut être confondu avec des noms de famille difficiles à prononcer ou peu courants dans une région, tels que « Xiulan ». Pour capturer de tels noms, vous pouvez demander à l'utilisateur de les saisir orthographe par lettre ou orthographe par mot.

Amazon Lex V2 propose trois styles de sélection d'emplacements que vous pouvez utiliser. Lorsque vous définissez un style d'élicitation de créneaux, cela change la façon dont Amazon Lex V2 interprète les données saisies par l'utilisateur.

Orthographe par lettre — Avec ce style, vous pouvez demander au bot d'écouter l'orthographe plutôt que la phrase entière. Par exemple, pour capturer un nom de famille tel que « Xiulan », vous pouvez demander à l'utilisateur d'épeler son nom de famille une lettre à la fois. Le bot saisira l'orthographe et transformera les lettres en un mot. Par exemple, si l'utilisateur dit « x i u l a n », le bot saisit le nom de famille sous la forme « xiulan ».

Orthographe par mot — Dans les conversations vocales, en particulier au téléphone, quelques lettres, telles que « t », « b », « p », ont un son similaire. Lorsque la capture de valeurs alphanumériques ou d'orthographe de noms entraîne une valeur incorrecte, vous pouvez demander à l'utilisateur de fournir un mot d'identification avec la lettre. Par exemple, si la réponse vocale à une demande d'identifiant de réservation est « abp123 », votre bot pourrait plutôt reconnaître l'expression « ab b 123 ». S'il s'agit d'une valeur incorrecte, vous pouvez demander à l'utilisateur de fournir l'entrée sous la forme « a comme dans alpha b comme dans boy p comme dans peter un deux trois ». Le bot résoudra l'entrée en « abp123 ».

Lorsque vous utilisez l'orthographe par mot, vous pouvez utiliser les formats suivants :

« comme dans » (comme dans Apple)
« pour » (a pour Apple)
« comme » (une pomme similaire)

Par défaut : il s'agit du style naturel de capture des emplacements utilisant la prononciation des mots. Par exemple, il peut naturellement capturer des noms tels que « John Stiles ». Si aucun style d'élicitation de créneaux n'est spécifié, le bot utilise le style par défaut. Pour les types d'emplacements de AMAZON.UKPostal code AMAZON.AlphaNumeric et, le style par défaut prend en charge la saisie orthographique par lettre.

Si le nom « Xiulan » est prononcé en utilisant un mélange de lettres et de mots, tel que « x comme dans x-ray i u l comme dans lion a n », le style d'élicitation de la machine à sous doit être défini sur style. spell-by-word Le spell-by-letter style ne le reconnaîtra pas.

Vous devez créer une interface vocale qui capture les valeurs des créneaux avec un style conversationnel naturel pour une meilleure expérience. Pour les entrées qui ne sont pas correctement capturées en utilisant le style naturel, vous pouvez demander à nouveau à l'utilisateur et définir le style d'élicitation des créneaux sur ou. spell-by-letter spell-by-word

Vous pouvez utiliser spell-by-word des spell-by-letter styles pour les types de machines à sous suivants en anglais (États-Unis), anglais (Royaume-Uni) et anglais (Australie) :

Activer l'orthographe

Vous activez spell-by-letter et, spell-by-word au moment de l'exécution, lorsque vous demandez des emplacements à l'utilisateur. Vous pouvez définir le style d'orthographe à l'aide de l'StartConversationopération PutSession RecognizeText RecognizeUtterance,, ou. Vous pouvez également activer spell-by-letter et spell-by-word utiliser une fonction Lambda.

Vous définissez le style orthographique en utilisant le dialogAction champ du sessionState champ dans la demande de l'une des opérations d'API susmentionnées ou lors de la configuration de la réponse Lambda (voir Préparation du format de réponse pour plus d'informations). Vous ne pouvez définir le style que lorsque l'action de dialogue est de type ElicitSlot et que l'emplacement à obtenir est l'un des types d'emplacements pris en charge.

Le code JSON suivant indique le dialogAction champ défini pour utiliser le spell-by-word style :


"dialogAction": {
    "slotElicitationStyle": "SpellByWord",
    "slotToElicit": "BookingId",
    "type": "ElicitSlot"
}

Le champ slotElicitationStyle peut avoir la valeur SpellByLetter, SpellByWord ou Default. Si vous ne spécifiez aucune valeur, la valeur est définie surDefault.

Note

Vous ne pouvez pas activer spell-by-letter ou obtenir de styles par le spell-by-word biais de la console.

Exemple de code

La modification du style orthographique est généralement effectuée si la première tentative de résolution d'une valeur de slot n'a pas fonctionné. L'exemple de code suivant est une fonction Lambda Python qui utilise le spell-by-word style lors de la deuxième tentative de résolution d'un slot.

Pour utiliser l'exemple de code, vous devez avoir :

Un bot avec une seule langue, l'anglais (GB) (en_GB).
Une intention, « CheckAccount » avec un exemple d'énoncé, « J'aimerais vérifier mon compte ». Assurez-vous que l'option Utiliser une fonction Lambda pour l'initialisation et la validation est sélectionnée dans la section Code hooks de la définition de l'intention.
L'intention doit comporter un emplacement, PostalCode « », du type AMAZON.UKPostalCode intégré.
Alias avec la fonction Lambda définie. Pour plus d'informations, consultez Création et association d'une fonction Lambda à un alias de bot.


import json
import time
import os
import logging

logger = logging.getLogger()
logger.setLevel(logging.DEBUG)

# --- Helpers that build all of the responses ---

def get_slots(intent_request):
    return intent_request['sessionState']['intent']['slots']

def get_session_attributes(intent_request):
    sessionState = intent_request['sessionState']
    if 'sessionAttributes' in sessionState:
        return sessionState['sessionAttributes']
    return {}

def get_slot(intent_request, slotName):
    slots = get_slots(intent_request)
    if slots is not None and slotName in slots and slots[slotName] is not None:
        logger.debug('resolvedValue={}'.format(slots[slotName]['value']['resolvedValues']))
        return slots[slotName]['value']['resolvedValues']
    else:
        return None

def elicit_slot(session_attributes, intent_request, slots, slot_to_elicit, slot_elicitation_style, message):
    return {'sessionState': {'dialogAction': {'type': 'ElicitSlot',
                                              'slotToElicit': slot_to_elicit,
                                              'slotElicitationStyle': slot_elicitation_style
                                              },
                             'intent': {'name': intent_request['sessionState']['intent']['name'],
                                        'slots': slots,
                                        'state': 'InProgress'
                                        },
                             'sessionAttributes': session_attributes,
                             'originatingRequestId': 'REQUESTID'
                             },
            'sessionId': intent_request['sessionId'],
            'messages': [ message ],
            'requestAttributes': intent_request['requestAttributes']
            if 'requestAttributes' in intent_request else None
            }

def build_validation_result(isvalid, violated_slot, slot_elicitation_style, message_content):
    return {'isValid': isvalid,
            'violatedSlot': violated_slot,
            'slotElicitationStyle': slot_elicitation_style,
            'message': {'contentType': 'PlainText', 
            'content': message_content}
            }

def GetItemInDatabase(postal_code):
    """
    Perform database check for transcribed postal code. This is a no-op
    check that shows that postal_code can't be found in the database.
    """
    return None

def validate_postal_code(intent_request):

    postal_code = get_slot(intent_request, 'PostalCode')

    if GetItemInDatabase(postal_code) is None:
        return build_validation_result(
            False,
            'PostalCode',
            'SpellByWord',
            "Sorry, I can't find your information. " +
            "To try again, spell out your postal " +
            "code using words, like a as in apple."
        )
    return {'isValid': True}

def check_account(intent_request):
    """
    Performs dialog management and fulfillment for checking an account
    with a postal code. Besides fulfillment, the implementation for this 
    intent demonstrates the following:
    1) Use of elicitSlot in slot validation and re-prompting.
    2) Use of sessionAttributes to pass information that can be used to
        guide a conversation.
    """
    slots = get_slots(intent_request)
    postal_code = get_slot(intent_request, 'PostalCode')
    session_attributes = get_session_attributes(intent_request)

    if intent_request['invocationSource'] == 'DialogCodeHook':
        # Validate the PostalCode slot. If any aren't valid, 
        # re-elicit for the value.
        validation_result = validate_postal_code(intent_request)
        if not validation_result['isValid']:
            slots[validation_result['violatedSlot']] = None
            return elicit_slot(
                session_attributes,
                intent_request,
                slots,
                validation_result['violatedSlot'],
                validation_result['slotElicitationStyle'],
                validation_result['message']
            )
    
        return close(
            intent_request,
            session_attributes,
            'Fulfilled',
            {'contentType': 'PlainText',
             'content': 'Thanks'
             }
        )

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': 'xxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
        },
        'messages': [ message ],
        'sessionId': intent_request['sessionId'],
        'requestAttributes': intent_request['requestAttributes'] if 'requestAttributes' in intent_request else None
    }

# --- Intents ---

def dispatch(intent_request):
    """
    Called when the user specifies an intent for this bot.
    """
    intent_name = intent_request['sessionState']['intent']['name']
    response = None

    # Dispatch to your bot's intent handlers
    if intent_name == 'CheckAccount':
        response = check_account(intent_request)

    return response

# --- Main handler ---

def lambda_handler(event, context):
    """
    Route the incoming request based on the intent.

    The JSON body of the request is provided in the event slot.
    """

    # By default, treat the user request as coming from 
    # Eastern Standard Time.
    os.environ['TZ'] = 'America/New_York'
    time.tzset()

    logger.debug('event={}'.format(json.dumps(event)))
    response = dispatch(event)
    logger.debug("response={}".format(json.dumps(response)))

    return response

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Amélioration de la reconnaissance des valeurs des créneaux grâce à des indices d'exécution

Surveillance des performances des robots