Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Captura de valores de ranura con estilos de ortografía durante la conversación
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 «ab**b**123» 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):
+ [AMAZON.AlphaNumeric](built-in-slot-alphanumeric.md)
+ [AMAZON.EmailAddress](built-in-slot-email.md)
+ [AMAZON.FirstName](built-in-slot-first-name.md)
+ [AMAZON.LastName](built-in-slot-last-name.md)
+ [AMAZON.UKPostalCode](built-in-slot-uk-postal-code.md)
+ [Tipos de slots personalizados](custom-slot-types.md)
## 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](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_PutSession.html), [RecognizeText](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_RecognizeText.html), [RecognizeUtterance](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_RecognizeUtterance.html) o [StartConversation](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_StartConversation.html). 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 [AWS Lambdaformato de respuesta para Lex V2](lambda-response-format.md) 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.
## Ejemplo de código con Lambda y Lex V2
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\$1GB).
+ 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 [Creación de una AWS Lambda función para su bot Amazon Lex V2](lambda-attach.md).
```
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
```