As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Capturando valores de slots com estilos de ortografia durante a conversa

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:

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 no raio-x i u l como no leão a n”, o estilo de elicitação do slot deve ser definido como estilo. spell-by-word O spell-by-letter estilo 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 elicitação do slot como ou. spell-by-letter spell-by-word

Você pode usar spell-by-word e spell-by-letter estilizar 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 spell-by-letter e spell-by-word em tempo de execução quando está obtendo slots do usuário. Você pode definir o estilo de ortografia com a StartConversationoperação PutSessionRecognizeText, RecognizeUtterance, ou. Você também pode ativar spell-by-letter e spell-by-word usar uma função Lambda.

Você define o estilo de ortografia usando o dialogAction campo do sessionState campo na solicitação de uma das API operações mencionadas acima ou ao configurar a resposta do Lambda (AWS Lambda formato de resposta para Lex V2consulte 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 JSON código a seguir mostra o dialogAction campo definido para usar o spell-by-word estilo:

"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.

Exemplo de código usando Lambda e Lex V2

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 Python Lambda que usa o spell-by-word estilo na segunda tentativa de resolver um slot.

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

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