Capturar valores de slot con deletreo

Amazon Lex V2 incluye slots integrados para capturar información específica del usuario, como nombre, apellidos, direcciones de correo electrónico o identificadores alfanuméricos. Por ejemplo, puede usar el slot AMAZON.LastName para capturar apellidos como "Jackson" o "Garcia". Sin embargo, Amazon Lex V2 puede confundirse con apellidos difíciles de pronunciar o que no son comunes en un lugar, como «Xiulan». Para capturar estos nombres, puede pedirle al usuario que introduzca la entrada deletreando por letras o deletreando por palabras.

Amazon Lex V2 ofrece tres estilos de obtención de estilos para su uso. Al establecer un estilo de obtención de slots, cambia la forma en que Amazon Lex V2 interpreta las entradas del usuario.

Deletrear por letra: con este estilo, puede indicarle al bot que escuche la ortografía en lugar de la frase completa. Por ejemplo, para capturar un apellido como «Xiulan», puede decirle al usuario que deletree su apellido letra por letra. El bot capturará la ortografía y resolverá las letras de una palabra. Por ejemplo, si el usuario dice «x i u l a n», el bot captura el apellido como «xiulan».

Deletrear por palabra: en las conversaciones de voz, especialmente por teléfono, hay algunas letras, como «t», «b», «p», que suenan de forma similar. Si al capturar valores alfanuméricos o al escribir nombres se obtiene un valor incorrecto, puede pedir al usuario que introduzca una palabra identificativa junto con la letra. Por ejemplo, si la respuesta de voz a una solicitud de identificador de reserva es «abp123», es posible que su bot reconozca la frase «abb123» en su lugar. Si el valor es incorrecto, puede pedirle al usuario que introduzca la entrada «a como en alfa, b como en boy, p como en peter, un dos tres». El bot resolverá la entrada como «abp123».

Puede usar los siguientes formatos para deletrear por palabra:

«como en» (como en manzana)
«para» (m para manzana)
«como» (a como manzana)

Predeterminado: este es el estilo natural de capturar slots utilizando la pronunciación de las palabras. Por ejemplo, puede capturar nombres como «John Stiles» de forma natural. Si no se especifica un estilo de obtención, el bot utiliza el estilo predeterminado. Para los tipos de slot con código AMAZON.AlphaNumeric y AMAZON.UKPostal, el estilo predeterminado admite el deletreo mediante la introducción de letras.

Si el nombre «Xiulan» se pronuncia con una combinación de letras y palabras, como «x como en rayos X i u l como en león a n», el estilo de obtención del slot debe configurarse para que se escriba por palabra. El estilo de deletreo por letra no lo reconocerá.

Debería crear una interfaz de voz que capture los valores de los slots con un estilo de conversación natural para una mejor experiencia. En el caso de entradas que no se capturen correctamente con el estilo natural, puede volver a preguntar al usuario y configurar el estilo de obtención de los slots como deletrear por letra o por palabra.

Puede usar los estilos de deletreo por palabra y por letra para los siguientes tipos de slots en inglés (EE. UU.), inglés (Reino Unido) e inglés (Australia):

Habilitar deletreo

Se habilita el deletreo por letra y por palabra en tiempo de ejecución cuando se están obteniendo slots del usuario. Puede configurar el estilo de deletreo con las operaciones PutSession, RecognizeText, RecognizeUtterance o StartConversation. También puede activar el deletreo por letra por palabra mediante una función de Lambda.

El estilo de deletreo se establece utilizando el campo dialogAction del campo sessionState en la solicitud de una de las operaciones de API antes mencionadas o al configurar la respuesta de Lambda (consulte Preparar el formato de respuesta para obtener más información). Solo puede establecer el estilo si el tipo de acción del diálogo es ElicitSlot y si el slot que se va a generar es uno de los tipos de slots compatibles.

El siguiente código JSON muestra el campo dialogAction configurado para usar el estilo de deletreo por palabra:


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

El campo slotElicitationStyle se puede definir en SpellByLetter, SpellByWord o Default. Si no especifica un valor, el valor predeterminado es Default.

nota

No puede activar los estilos de obtención con deletreo por letra o por palabra en la consola.

Código de ejemplo

Por lo general, se cambia el estilo de deletreo al intentar resolver por primera vez un valor de slot que no funcionó. El siguiente ejemplo de código es una función de Lambda de Python que utiliza el estilo de deletreo por palabra en el segundo intento de resolver un slot.

Para utilizar el código de ejemplo, debe disponer de lo siguiente:

Un bot con un idioma, inglés (GB) (en_GB).
Una intención, «ComprobarCuenta» con un ejemplo de enunciado: «Me gustaría comprobar mi cuenta». Asegúrese de que la opción Utilizar una función de Lambda para la inicialización y la validación esté seleccionada en la sección Enlaces de códigos de la definición de intención.
La intención debe tener un slot, "CódigoPostal" del tipo integrado AMAZON.UKPostalCode.
Un alias con la función de Lambda definida. Para obtener más información, consulte Crear y adjuntar una función de Lambda a 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

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Mejorar el reconocimiento de los valores de los slots con sugerencias en tiempo de ejecución

Monitoreo del rendimiento de los bots