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 di ortografia durante la conversazione

Amazon Lex V2 offre slot integrati per acquisire informazioni specifiche dell'utente come nome, cognome, indirizzo email o identificatori alfanumerici. Ad esempio, puoi utilizzare lo AMAZON.LastName slot per acquisire cognomi come «Jackson» o «Garcia». Tuttavia, Amazon Lex V2 può essere confuso con cognomi difficili da pronunciare o non comuni in una località, come «Xiulan». Per acquisire tali nomi, puoi chiedere all'utente di fornire lo stile ortografico per lettera o ortografia per parola.

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

Ortografia per lettera: con questo stile, puoi chiedere al bot di ascoltare l'ortografia anziché l'intera frase. Ad esempio, per acquisire un cognome come «Xiulan», puoi dire all'utente di scrivere il proprio 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, ci sono alcune lettere, come «t», «b», «p», che hanno un suono simile. Quando l'acquisizione di valori alfanumerici o l'ortografia dei nomi risulta errato, è possibile richiedere all'utente di fornire una parola identificativa insieme alla lettera. Ad esempio, se la risposta vocale a una richiesta di 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 as in alpha b as in boy p as in peter one two three». Il bot risolverà l'input in «abp123".

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

Per inglese (Stati Uniti), inglese (Regno Unito) e inglese (Australia):

Per il tedesco (de-DE):

Per il francese (fr-FR):

Per lo spagnolo (es-419, es-US, es-ES):

Predefinito: questo è lo stile naturale di acquisizione degli slot che utilizza la pronuncia delle parole. Ad esempio, è in grado di 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 utilizzando una combinazione di lettere e parole, ad esempio «x as in x-ray i u l as in lion a n», lo stile di elicitazione degli slot deve essere impostato sullo stile ortografia per parola. Lo stile ortografico per lettera non lo riconoscerà.

Dovresti 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, puoi richiedere nuovamente all'utente e impostare lo stile di elicitazione degli slot su ortografia per lettera o ortografia per parola.

Puoi utilizzare gli stili ortografia per parola e ortografia per lettera per i seguenti tipi di slot nelle lingue inglese (USA), inglese (Regno Unito), inglese (Australia), tedesco (de-DE), francese (fr-FR) e spagnolo (es-419, es-US, es-ES):

Abilitare l'ortografia

Si abilita l'ortografia per lettera e l'ortografia per parola in fase di esecuzione quando si ottengono gli slot dall'utente. È possibile impostare lo stile di ortografia con l'operazione,, o. PutSession RecognizeText RecognizeUtterance StartConversation Puoi anche abilitare l'ortografia per lettera e l'ortografia per parola usando una funzione Lambda.

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

Il seguente codice JSON mostra il dialogAction campo impostato per utilizzare lo stile ortografia per parola:

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

Codice di esempio che utilizza Lambda e Lex V2

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

Per utilizzare il codice di esempio, è necessario disporre di:

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