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

Usa i punteggi di confidenza nella trascrizione vocale per migliorare le conversazioni con il tuo bot Lex V2

Quando un utente pronuncia una voce, Amazon Lex V2 utilizza il riconoscimento vocale automatico (ASR) per trascrivere la richiesta dell'utente prima che venga interpretata. Per impostazione predefinita, Amazon Lex V2 utilizza la trascrizione più probabile dell'audio per l'interpretazione.

In alcuni casi potrebbe esserci più di una possibile trascrizione dell'audio. Ad esempio, un utente potrebbe emettere un enunciato con un suono ambiguo, ad esempio «Mi chiamo John», che potrebbe essere inteso come «Mi chiamo Juan». In questo caso, puoi utilizzare tecniche di disambiguazione o combinare le tue conoscenze di dominio con il punteggio di confidenza della trascrizione per determinare quale trascrizione in un elenco di trascrizioni è quella corretta.

Amazon Lex V2 include la trascrizione principale e fino a due trascrizioni alternative per l'input dell'utente nella richiesta alla funzione code hook Lambda. Ogni trascrizione contiene un punteggio di affidabilità che indica che si tratta della trascrizione corretta. Ogni trascrizione include anche tutti i valori degli slot desunti dall'input dell'utente.

È possibile confrontare i punteggi di confidenza di due trascrizioni per determinare se vi è ambiguità tra di esse. Ad esempio, se una trascrizione ha un punteggio di confidenza di 0,95 e l'altra ha un punteggio di confidenza di 0,65, la prima trascrizione è probabilmente corretta e l'ambiguità tra di esse è bassa. Se le due trascrizioni hanno punteggi di confidenza di 0,75 e 0,72, l'ambiguità tra loro è elevata. Potresti essere in grado di distinguerle utilizzando le tue conoscenze di dominio.

Ad esempio, se i valori degli slot dedotti in due trascrizioni con un punteggio di confidenza di 0,75 e 0,72 sono «John» e «Juan», puoi interrogare gli utenti del tuo database per verificare l'esistenza di questi nomi ed eliminare una delle trascrizioni. Se «John» non è un utente nel tuo database e «Juan» lo è, puoi usare l'hook del codice di dialogo per modificare il valore dello slot dedotto per il nome in «Juan».

I punteggi di fiducia restituiti da Amazon Lex V2 sono valori comparativi. Non fare affidamento su di essi come punteggio assoluto. I valori possono cambiare in base ai miglioramenti apportati ad Amazon Lex V2.

I punteggi di confidenza nella trascrizione audio sono disponibili solo nelle lingue inglese (GB) (en_GB) e inglese (US) (en_US). I punteggi di confidenza sono supportati solo per 8 ingressi audio. kHz I punteggi di confidenza nella trascrizione non vengono forniti per l'ingresso audio dalla finestra di test sulla console Amazon Lex V2 perché utilizza 16 kHz ingressi audio.

Puoi utilizzare i punteggi di confidenza per più modelli di progettazione delle conversazioni:

Amazon Lex V2 invia la seguente JSON struttura con un massimo di tre trascrizioni per l'input dell'utente alla funzione code hook Lambda:

    "transcriptions": [
        {
            "transcription": "string",
            "rawTranscription": "string",
            "transcriptionConfidence": "number",
            },
            "resolvedContext": {
                "intent": "string"
            },
            "resolvedSlots": {
                "string": {
                    "shape": "List",
                    "value": {
                        "originalValue": "string",
                        "resolvedValues": [
                            "string"
                        ]
                    },
                    "values": [
                        {
                            "shape": "Scalar",
                            "value": {
                                "originalValue": "string",
                                "resolvedValues": [
                                    "string"
                                ]
                            }
                        },
                        {
                            "shape": "Scalar",
                            "value": {
                                "originalValue": "string",
                                "resolvedValues": [
                                    "string"
                                ]
                            }
                        }
                    ]
                }
            }
        }
    ]
     

La JSON struttura contiene il testo di trascrizione, l'intento che è stato risolto per l'enunciato e i valori per tutti gli slot rilevati nell'enunciato. Per quanto riguarda l'immissione di testo da parte dell'utente, le trascrizioni contengono una sola trascrizione con un punteggio di confidenza di 1,0.

Il contenuto delle trascrizioni dipende dalla svolta della conversazione e dall'intento riconosciuto.

Per il primo turno, ossia l'evocazione degli intenti, Amazon Lex V2 determina le prime tre trascrizioni. Per la trascrizione principale, restituisce l'intento e tutti i valori degli slot dedotti nella trascrizione.

Nei turni successivi, ossia l'elicitazione degli slot, i risultati dipendono dall'intento dedotto per ciascuna delle trascrizioni, come segue.

Gestione della sessione

Per modificare l'intento utilizzato da Amazon Lex V2 in una conversazione con l'utente, usa la risposta della funzione Lambda del tuo hook di codice di dialogo. Oppure puoi utilizzare la gestione delle sessioni APIs nella tua applicazione personalizzata.

Utilizzo di una funzione Lambda con il bot Lex V2

Quando usi una funzione Lambda, Amazon Lex V2 la chiama con una JSON struttura che contiene l'input della funzione. La JSON struttura contiene un campo chiamato transcriptions che contiene le possibili trascrizioni che Amazon Lex V2 ha determinato per l'enunciato. Il transcriptions campo contiene da una a tre trascrizioni possibili, ognuna con un punteggio di confidenza.

Per utilizzare l'intento di una trascrizione alternativa, lo specifichi nell'azione di ElicitSlot dialogo ConfirmIntent o nella funzione Lambda. Per utilizzare un valore di slot da una trascrizione alternativa, imposta il valore nel intent campo nella risposta della funzione Lambda. Per ulteriori informazioni, consulta Integrazione di un AWS Lambda funzione nel tuo bot.

Codice di esempio che utilizza Lambda con Lex V2

Il seguente esempio di codice è una funzione Python Lambda che utilizza trascrizioni audio per migliorare l'esperienza di conversazione per l'utente.

Per utilizzare il codice di esempio, devi avere:

import time
import os
import logging

logger = logging.getLogger()
logger.setLevel(logging.DEBUG)


# --- Helpers that build all of the responses ---

def elicit_slot(session_attributes, intent_request, slots, slot_to_elicit, message):
    return {
        'sessionState': {
            'dialogAction': {
                'type': 'ElicitSlot',
                'slotToElicit': slot_to_elicit
            },
            'intent': {
                'name': intent_request['sessionState']['intent']['name'],
                'slots': slots,
                'state': 'InProgress'
            },
            'sessionAttributes': session_attributes,
            'originatingRequestId': 'e3ab4d42-fb5f-4cc3-bb78-caaf6fc7cccd'
        },
        'sessionId': intent_request['sessionId'],
        'messages': [message],
        'requestAttributes': intent_request['requestAttributes'] if 'requestAttributes' in intent_request else None
    }


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': '3ab4d42-fb5f-4cc3-bb78-caaf6fc7cccd'
        },
        'messages': [message],
        'sessionId': intent_request['sessionId'],
        'requestAttributes': intent_request['requestAttributes'] if 'requestAttributes' in intent_request else None
    }


def delegate(intent_request, session_attributes):
    return {
        'sessionState': {
            'dialogAction': {
                'type': 'Delegate'
            },
            'intent': intent_request['sessionState']['intent'],
            'sessionAttributes': session_attributes,
            'originatingRequestId': 'abc'
        },
        'sessionId': intent_request['sessionId'],
        'requestAttributes': intent_request['requestAttributes'] if 'requestAttributes' in intent_request else None
    }


def get_session_attributes(intent_request):
    sessionState = intent_request['sessionState']
    if 'sessionAttributes' in sessionState:
        return sessionState['sessionAttributes']

    return {}


def get_slots(intent_request):
    return intent_request['sessionState']['intent']['slots']


""" --- Functions that control the behavior of the bot --- """


def order_birth_stone(intent_request):
    """
    Performs dialog management and fulfillment for ordering a birth stone.
    Beyond fulfillment, the implementation for this intent demonstrates the following:
    1) Use of N best transcriptions to re prompt user when confidence for top transcript is below a threshold
    2) Overrides resolved slot for birth month from a known fixed list if the top transcript
    is not accurate.
    """

    transcriptions = intent_request['transcriptions']

    if intent_request['invocationSource'] == 'DialogCodeHook':
        # Disambiguate if there are multiple transcriptions and the top transcription
        # confidence is below a threshold (0.8 here)
        if len(transcriptions) > 1 and transcriptions[0]['transcriptionConfidence'] < 0.8:
            if transcriptions[0]['resolvedSlots'] is not {} and 'Name' in transcriptions[0]['resolvedSlots'] and \
                    transcriptions[0]['resolvedSlots']['Name'] is not None:
                return prompt_for_name(intent_request)
            elif transcriptions[0]['resolvedSlots'] is not {} and 'BirthMonth' in transcriptions[0]['resolvedSlots'] and \
                    transcriptions[0]['resolvedSlots']['BirthMonth'] is not None:
                return validate_month(intent_request)

    return continue_conversation(intent_request)


def prompt_for_name(intent_request):
    """
    If the confidence for the name is not high enough, re prompt the user with the recognized names
    so it can be confirmed.
    """
    resolved_names = []
    for transcription in intent_request['transcriptions']:
        if transcription['resolvedSlots'] is not {} and 'Name' in transcription['resolvedSlots'] and \
                transcription['resolvedSlots']['Name'] is not None:
            resolved_names.append(transcription['resolvedSlots']['Name']['value']['originalValue'])
    if len(resolved_names) > 1:
        session_attributes = get_session_attributes(intent_request)
        slots = get_slots(intent_request)
        return elicit_slot(session_attributes, intent_request, slots, 'Name',
                           {'contentType': 'PlainText',
                            'content': 'Sorry, did you say your name is {} ?'.format(" or ".join(resolved_names))})
    else:
        return continue_conversation(intent_request)


def validate_month(intent_request):
    """
    Validate month from an expected list, if not valid looks for other transcriptions and to see if the month
    recognized there has an expected value. If there is, replace with that and if not continue conversation.
    """

    expected_months = ['january', 'february', 'march']
    resolved_months = []
    for transcription in intent_request['transcriptions']:
        if transcription['resolvedSlots'] is not {} and 'BirthMonth' in transcription['resolvedSlots'] and \
                transcription['resolvedSlots']['BirthMonth'] is not None:
            resolved_months.append(transcription['resolvedSlots']['BirthMonth']['value']['originalValue'])

    for resolved_month in resolved_months:
        if resolved_month in expected_months:
            intent_request['sessionState']['intent']['slots']['BirthMonth']['resolvedValues'] = [resolved_month]
            break

    return continue_conversation(intent_request)


def continue_conversation(event):
    session_attributes = get_session_attributes(event)

    if event["invocationSource"] == "DialogCodeHook":
        return delegate(event, session_attributes)


# --- Intents ---


def dispatch(intent_request):
    """
    Called when the user specifies an intent for this bot.
    """

    logger.debug('dispatch sessionId={}, intentName={}'.format(intent_request['sessionId'],
                                                               intent_request['sessionState']['intent']['name']))

    intent_name = intent_request['sessionState']['intent']['name']

    # Dispatch to your bot's intent handlers
    if intent_name == 'OrderBirthStone':
        return order_birth_stone(intent_request)

    raise Exception('Intent with name ' + intent_name + ' not supported')


# --- Main handler ---


def lambda_handler(event, context):
    """
    Route the incoming request based on intent.
    The JSON body of the request is provided in the event slot.

    """
    # By default, treat the user request as coming from the America/New_York time zone.
    os.environ['TZ'] = 'America/New_York'
    time.tzset()
    logger.debug('event={}'.format(event))

    return dispatch(event)

Utilizzo della gestione della sessione API per scegliere un valore di intento o slot diverso

Per utilizzare un intento diverso da quello corrente, usa l'operazione. PutSession Ad esempio, se decidi che la prima alternativa è preferibile all'intento scelto da Amazon Lex V2, puoi utilizzare l'PutSessionoperazione per modificare gli intenti. In questo modo l'intento successivo con cui l'utente interagisce sarà quello selezionato.

È inoltre possibile utilizzare l'PutSessionoperazione per modificare il valore dello slot nella intent struttura in modo da utilizzare un valore proveniente da una trascrizione alternativa.

Per ulteriori informazioni, consulta Comprendere le sessioni bot di Amazon Lex V2.