Ativação da soletração Código de exemplo

Capturar valores de slots com estilos de soletração

O Amazon Lex V2 fornece slots integrados para capturar informações específicas do usuário, como nome, sobrenome, endereço de e-mail ou identificadores alfanuméricos. Por exemplo, você pode usar o slot AMAZON.LastName para capturar sobrenomes como “Jackson” ou “Garcia”. No entanto, o Amazon Lex V2 pode se confundir com sobrenomes difíceis de pronunciar ou que não são comuns em uma localidade, como “Xiulan”. Para capturar esses nomes, você pode pedir ao usuário para fornecer as informações soletrando por letra ou soletrando por palavra.

O Amazon Lex V2 oferece três estilos de escolha de slots para você usar. Quando você define um estilo de escolha de slots, ele muda a forma como o Amazon Lex V2 interpreta a entrada do usuário.

Soletrar por letra – Com esse estilo, você pode instruir o bot a ouvir a soletração em vez da frase inteira. Por exemplo, para capturar um sobrenome como “Xiulan”, você pode pedir ao usuário para soletrar o sobrenome, uma letra por vez. O bot capturará a soletração e converterá as letras em uma palavra. Por exemplo, se o usuário disser “x i u l a n”, o bot captura o sobrenome como “xiulan”.

Soletrar por palavra – Em conversas de voz, especialmente usando o telefone, existem algumas letras, como “t”, “b”, “p”, que têm sons semelhantes. Quando a captura de valores alfanuméricos ou soletração de nomes resulta em um valor incorreto, você pode solicitar que o usuário forneça uma palavra de identificação junto com a letra. Por exemplo, se a resposta de voz a uma solicitação de ID de reserva for “abp123”, seu bot poderá reconhecer a frase “abb123”. Se esse for um valor incorreto, você pode pedir ao usuário que forneça a entrada como “a como em alfa, b como em bola, p como em Pedro, um, dois, três”. O bot converterá a entrada em “abp123”.

Ao usar a soletração por palavra, é possível usar os seguintes formatos:

“como em” (a como em maçã)
“de” (a de maçã)
“como” (a como maçã)

Padrão – Esse é o estilo natural de captura de slots que usa a pronúncia de palavras. Por exemplo, ele pode capturar nomes como “John Stiles” naturalmente. Se um estilo de escolha de slots não for especificado, o bot usará o estilo padrão. Para os tipos de slot de código AMAZON.AlphaNumeric e AMAZON.UKPostal, o estilo padrão é compatível com a entrada soletrada por letra.

Se o nome “Xiulan” for falado usando uma mistura de letras e palavras, como “x como em xarope, i, u, l como em leão, a, n”, o estilo de escolha do slot deve ser definido como soletração por palavra. O estilo de soletração por letra não o reconhecerá.

É necessário criar uma interface de voz que capture os valores dos slots com um estilo conversacional natural para uma melhor experiência. Para entradas que não foram capturadas corretamente usando o estilo natural, você pode solicitar novamente ao usuário e definir o estilo de escolha do slot como soletração por letra ou por palavra.

É possível usar estilos de soletração por palavra e soletração por letra para os seguintes tipos de slots nos idiomas inglês (EUA), inglês (Reino Unido) e inglês (Austrália):

Ativação da soletração

Você ativa a soletração por letra e a soletração por palavra em runtime quando está escolhendo slots do usuário. Você pode definir o estilo de soletração com a operação PutSession, RecognizeText, RecognizeUtterance ou StartConversation. Também é possível ativar a soletração por letra e a soletração por palavra usando uma função do Lambda.

Defina o estilo de soletração usando o campo dialogAction do campo sessionState na solicitação de uma das operações de API mencionadas acima ou ao configurar a resposta do Lambda (consulte Preparando o formato de resposta para obter mais informações). Só é possível definir o estilo quando o tipo de ação da caixa de diálogo é ElicitSlot e quando o slot a ser escolhido é um dos tipos de slot compatíveis.

O código JSON a seguir mostra o campo dialogAction definido para usar o estilo de soletração por palavra:


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

O campo slotElicitationStyle pode ser definido como SpellByLetter, SpellByWord ou Default. Se você não especificar um valor, o valor padrão é definido como Default.

nota

Não é possível habilitar estilos de escolha de soletração por letra ou por palavra no console.

Código de exemplo

Geralmente, a alteração do estilo de soletração é realizada se a primeira tentativa de converter um valor de slot não funcionar. O exemplo de código a seguir é uma função do Lambda em Python que usa o estilo de soletração por palavra na segunda tentativa de resolver um slot.

Para usar o código de exemplo, é necessário ter:

Um bot com um idioma, inglês (GB) (en_GB).
Uma intenção, “CheckAccount” com um exemplo de enunciado, “Eu gostaria de verificar minha conta”. Certifique-se de que a opção Usar uma função do Lambda para inicialização e validação esteja selecionada na seção Hooks de código da definição da intenção.
A intenção deve ter um slot, “PostalCode”, do tipo integrado AMAZON.UKPostalCode.
Um alias com a função do Lambda definida. Para obter mais informações, consulte Criar e anexar uma função do Lambda a um 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

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Melhorar o reconhecimento dos valores de slots com sugestões de runtime

Monitorar desempenho do bot