Abilitare l'ortografia Codice di esempio

Acquisizione dei valori degli slot con stili di ortografia

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 come in alpha b come in boy p come in peter one two three». Il bot risolverà l'input in «abp123».

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

«come in» (come in apple)
«per» (a per mela)
«mi piace» (una mela simile)

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, ad esempio «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, RecognizeText RecognizeUtterance, o StartConversation. È inoltre possibile abilitare spell-by-letter e spell-by-word utilizzare 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 (Preparazione del formato di rispostavedi per ulteriori 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 seguente codice JSON 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 Default su.

Nota

Non puoi abilitare spell-by-letter o spell-by-word evocare stili tramite la console.

Codice di esempio

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, è necessario disporre di:

Un bot con una sola lingua, inglese (GB) (en_GB).
Un intento, "CheckAccount" con un esempio di espressione: «Vorrei controllare il mio account». Assicurati che l'opzione Usa una funzione Lambda per l'inizializzazione e la convalida sia selezionata nella sezione Code hook della definizione dell'intento.
L'intento deve avere uno slot, "PostalCode«, del tipo integrato. AMAZON.UKPostalCode
Un alias con la funzione Lambda definita. Per ulteriori informazioni, consulta Creazione e associazione di una funzione Lambda a un alias 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

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Miglioramento del riconoscimento dei valori degli slot con suggerimenti di runtime

Monitoraggio delle prestazioni dei bot