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):
+ «as in» (a as in apple)
+ «per» (a per Apple)
+ «mi piace» (una mela simile)
Per il tedesco (de-DE):
+ «vino» (p vino, pizza)
+ «für» (p per pizza)
Per il francese (fr-FR):
+ «comme» (p comme paris)
+ «per» (p per Parigi)
Per lo spagnolo (es-419, es-US, es-ES):
+ «como» (u como union)
+ «de» (u de union)
**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):
+ [AMAZON.AlphaNumeric](built-in-slot-alphanumeric.md)
+ [AMAZON.EmailAddress](built-in-slot-email.md)
+ [AMAZON.FirstName](built-in-slot-first-name.md)
+ [AMAZON.LastName](built-in-slot-last-name.md)
+ [AMAZON.UKPostalCode](built-in-slot-uk-postal-code.md)(solo inglese (Stati Uniti), inglese (Regno Unito) e inglese (Australia))
+ [Tipi di slot personalizzati ](custom-slot-types.md)
## 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 ](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_PutSession.html) [ RecognizeText ](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_RecognizeText.html) [ RecognizeUtterance ](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_RecognizeUtterance.html) [ StartConversation ](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_StartConversation.html) 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](lambda-response-format.md) È 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`
**Nota**
Non puoi abilitare gli stili di elicitazione ortografica per lettera o ortografia per parola tramite la console.
## 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:
+ Un bot con una sola lingua, l'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 hooks ** 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 di una AWS Lambda funzione per il tuo bot Amazon Lex V2](lambda-attach.md).
```
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
```