Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Acquisizione dei valori degli slot con stili ortografici durante la conversazione

Amazon Lex V2 offre slot integrati per acquisire informazioni specifiche dell'utente come nome, cognome, indirizzo e-mail o identificatori alfanumerici. Ad esempio, puoi utilizzare lo AMAZON.LastName slot per acquisire cognomi come «Jackson» o «Garcia». Tuttavia, Amazon Lex V2 può confondersi con cognomi difficili da pronunciare o non comuni in un locale, come «Xiulan». Per acquisire tali nomi, puoi chiedere all'utente di inserire i dati ortografia per lettera o ortografia per stile di parola.

Amazon Lex V2 offre tre stili di elicitazione degli slot da utilizzare. Quando si imposta uno stile di elicitazione degli slot, cambia il modo in cui Amazon Lex V2 interpreta l'input dell'utente.

Ortografia per lettera: con questo stile, puoi indicare al bot di ascoltare l'ortografia anziché l'intera frase. Ad esempio, per registrare un cognome come «Xiulan», puoi dire all'utente di pronunciare il cognome una lettera alla volta. Il bot acquisirà l'ortografia e risolverà le lettere in una parola. Ad esempio, se l'utente dice «x i u l a n», il bot acquisisce il cognome come «xiulan».

Ortografia per parola: nelle conversazioni vocali, specialmente al telefono, alcune lettere, come «t», «b», «p», hanno un suono simile. Quando l'acquisizione di valori alfanumerici o l'ortografia dei nomi restituisce un valore errato, è possibile richiedere all'utente di fornire una parola identificativa insieme alla lettera. Ad esempio, se la risposta vocale a una richiesta di un ID di prenotazione è «abp123", il bot potrebbe invece riconoscere la frase «ab b 123". Se questo è un valore errato, puoi chiedere all'utente di fornire l'input come «a in alpha b as in boy p as in peter one two three». Il bot risolverà l'input in «abp123».

Quando si utilizza ortografia per parola, è possibile utilizzare i seguenti formati:

Predefinito: questo è lo stile naturale di acquisizione delle slot utilizzando la pronuncia delle parole. Ad esempio, può acquisire nomi come «John Stiles» in modo naturale. Se non viene specificato uno stile di elicitazione degli slot, il bot utilizza lo stile predefinito. Per i tipi di slot AMAZON.AlphaNumeric e AMAZON.UKPostal code, lo stile predefinito supporta l'immissione ortografica per lettera.

Se il nome «Xiulan» viene pronunciato usando una combinazione di lettere e parole, come «x as in x-ray i u l as in lion a n», lo stile di elicitazione degli slot deve essere impostato su style. spell-by-word Lo spell-by-letter stile non lo riconoscerà.

È necessario creare un'interfaccia vocale che acquisisca i valori degli slot con uno stile di conversazione naturale per un'esperienza migliore. Per gli input che non vengono acquisiti correttamente utilizzando lo stile naturale, è possibile ripetere la richiesta all'utente e impostare lo stile di elicitazione dello slot su or. spell-by-letter spell-by-word

È possibile utilizzare spell-by-word e spell-by-letter stili per i seguenti tipi di slot nelle lingue inglese (Stati Uniti), inglese (Regno Unito) e inglese (Australia):

Abilitare l'ortografia

Si attiva spell-by-letter e spell-by-word in fase di esecuzione quando si ottengono slot dall'utente. È possibile impostare lo stile di ortografia con l'PutSessionoperazione, RecognizeTextRecognizeUtterance, o StartConversation. È inoltre possibile abilitare spell-by-letter e spell-by-word utilizzare una funzione Lambda.

Puoi impostare lo stile ortografico utilizzando il dialogAction campo del sessionState campo nella richiesta di una delle API operazioni sopra menzionate o durante la configurazione della risposta Lambda (AWS Lambda formato di risposta per Lex V2vedi per maggiori informazioni). È possibile impostare lo stile solo quando il tipo di azione del dialogo è ElicitSlot e quando lo slot da suscitare è uno dei tipi di slot supportati.

Il JSON codice seguente mostra il dialogAction campo impostato per utilizzare lo spell-by-word stile:

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

Il campo slotElicitationStyle può essere impostato su SpellByLetter, SpellByWord o Default. Se non si specifica un valore, il valore viene impostato suDefault.

Codice di esempio con Lambda e Lex V2

La modifica dello stile ortografico viene in genere eseguita se il primo tentativo di risolvere un valore dello slot non ha funzionato. Il seguente esempio di codice è una funzione Python Lambda che utilizza spell-by-word lo stile nel secondo tentativo di risolvere uno slot.

Per utilizzare il codice di esempio, devi avere:

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