Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Capture des valeurs des créneaux avec des styles d'orthographe pendant la conversation

Amazon Lex V2 propose 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 l'AMAZON.LastNameemplacement pour saisir des noms de famille tels que « Jackson » ou « Garcia ». Amazon Lex V2 peut toutefois être confondu avec des noms de famille difficiles à prononcer ou peu courants dans une région, tels que « Xiulan ». Pour saisir de tels noms, vous pouvez demander à l'utilisateur de saisir des informations dans un style orthographe par lettre ou orthographe par mot.

Amazon Lex V2 propose trois styles d'élicitation d'emplacements que vous pouvez utiliser. Lorsque vous définissez un style d'élicitation des emplacements, cela modifie la façon dont Amazon Lex V2 interprète les entrées de l'utilisateur.

Orthographe par lettre — Avec ce style, vous pouvez demander au robot d'écouter l'orthographe plutôt que la phrase entière. Par exemple, pour saisir un nom de famille tel que « Xiulan », vous pouvez demander à l'utilisateur d'épeler son nom de famille lettre par lettre. Le bot saisira l'orthographe et résoudra 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, certaines lettres, telles que « t », « b », « p », ont un son similaire. Lorsque la saisie de valeurs alphanumériques ou de noms orthographiques 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 la phrase « ab b 123 ». S'il s'agit d'une valeur incorrecte, vous pouvez demander à l'utilisateur de fournir la saisie 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 :

Pour l'anglais (États-Unis), l'anglais (Royaume-Uni) et l'anglais (Australie) :

Pour l'allemand (de-DE) :

Pour le français (fr-FR) :

Pour l'espagnol (es-419, es-US, es-ES) :

Par défaut  : il s'agit du style naturel de capture des machines à sous utilisant la prononciation des mots. Par exemple, il peut capturer naturellement des noms tels que « John Stiles ». Si aucun style d'élicitation d'emplacement 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é à l'aide d'un mélange de lettres et de mots, tels que « x comme dans les rayons X i u l comme dans le lion a n », le style d'élicitation des emplacements doit être défini sur le style orthographe par mot. Le style orthographe par lettre ne le reconnaîtra pas.

Vous devez créer une interface vocale qui capture les valeurs des emplacements avec un style conversationnel naturel pour une meilleure expérience. Pour les entrées qui ne sont pas correctement capturées à l'aide du style naturel, vous pouvez réinviter l'utilisateur et définir le style d'élicitation des emplacements sur orthographe par lettre ou orthographe par mot.

Vous pouvez utiliser des styles d'orthographe par mot et d'orthographe par lettre pour les types de créneaux suivants en anglais (États-Unis), anglais (Royaume-Uni), anglais (Australie), allemand (de-DE), français (fr-FR) et espagnol (es-419, es-US, es-ES) :

Activer l'orthographe

Vous activez l'orthographe par lettre et l'orthographe par mot lors de l'exécution lorsque vous demandez des créneaux à l'utilisateur. Vous pouvez définir le style orthographique à l'aide de l'StartConversationopération PutSession RecognizeText RecognizeUtterance,, ou. Vous pouvez également activer l'orthographe par lettre et l'orthographe par mot à l'aide d'une fonction Lambda.

Vous définissez le style orthographique à l'aide du 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 AWS Lambdaformat de réponse pour Lex V2 pour plus d'informations). Vous ne pouvez définir le style que lorsque le type d'action de la boîte de dialogue est ElicitSlot et lorsque l'emplacement à obtenir est l'un des types d'emplacement pris en charge.

Le code JSON suivant montre le dialogAction champ configuré pour utiliser le style orthographe par mot :

"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, celle-ci est définie surDefault.

Exemple de code utilisant Lambda et Lex V2

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

Pour utiliser l'exemple de code, vous devez disposer des éléments suivants :

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