Utilizzo dei punteggi di confidenza nella trascrizione vocale

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 l'ingresso audio a 8 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 un ingresso audio a 16 kHz.

Nota

Prima di poter utilizzare i punteggi di confidenza della trascrizione audio con un bot esistente, devi prima ricostruire il bot. Le versioni esistenti di un bot non supportano i punteggi di confidenza nella trascrizione. È necessario creare una nuova versione del bot per utilizzarle.

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

• Se il punteggio di confidenza più elevato scende al di sotto di una soglia a causa di un ambiente rumoroso o di una scarsa qualità del segnale, puoi chiedere all'utente con la stessa domanda di acquisire un audio di qualità migliore.

• Se più trascrizioni hanno punteggi di confidenza simili per i valori degli slot, ad esempio «John» e «Juan», puoi confrontare i valori con un database preesistente per eliminare gli input oppure puoi richiedere all'utente di selezionare uno dei due valori. Ad esempio, «pronuncia 1 per John o 2 per Juan».

• Se la tua logica aziendale richiede il cambio di intento in base a parole chiave specifiche in una trascrizione alternativa con un punteggio di affidabilità vicino alla trascrizione superiore, puoi modificare l'intento utilizzando la funzione Lambda del codice di dialogo o utilizzando le operazioni di gestione delle sessioni. Per ulteriori informazioni, consulta Gestione della sessione.

Amazon Lex V2 invia la seguente struttura JSON 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 struttura JSON 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.

• Se l'intento dedotto per la trascrizione principale è lo stesso del turno precedente e tutte le altre trascrizioni hanno lo stesso intento, allora

  • Tutte le trascrizioni contengono valori di slot dedotti.

     

• Se l'intento dedotto per la trascrizione principale è diverso dal turno precedente e tutte le altre trascrizioni hanno l'intento precedente, allora

  • La trascrizione superiore contiene i valori degli slot dedotti per il nuovo intento.

  • Le altre trascrizioni hanno l'intento precedente e i valori degli slot dedotti per l'intento precedente.

     

• Se l'intento dedotto per la trascrizione principale è diverso dal turno precedente, una trascrizione è uguale all'intento precedente e una trascrizione ha un intento diverso, allora

  • La trascrizione principale contiene il nuovo intento dedotto e tutti i valori degli slot dedotti nell'enunciato.

  • La trascrizione che ha l'intento dedotto precedente contiene i valori degli slot dedotti per quell'intento.

  • La trascrizione con l'intento diverso non ha un nome di intento dedotto né valori di slot dedotti.

     

• Se l'intento dedotto per la trascrizione principale è diverso da quello del turno precedente e tutte le altre trascrizioni hanno intenti diversi, allora

  • La trascrizione principale contiene il nuovo intento dedotto e tutti i valori degli slot dedotti nell'enunciato.

  • Le altre trascrizioni non contengono intenti dedotti né valori di slot dedotti.

     

• Se l'intento dedotto per le prime due trascrizioni è lo stesso e diverso dal turno precedente, e la terza trascrizione ha un intento diverso, allora

  • Le prime due trascrizioni contengono il nuovo intento dedotto e tutti i valori degli slot dedotti nell'enunciato.

  • La terza trascrizione non ha un nome di intento e non ha valori di slot risolti.

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 le API di gestione delle sessioni nella tua applicazione personalizzata.

Utilizzo di una funzione Lambda

Quando usi una funzione Lambda, Amazon Lex V2 la chiama con una struttura JSON che contiene l'input della funzione. La struttura JSON 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 affidabilità.

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 Abilitazione della logica personalizzata con AWS Lambda funzioni.

Codice di esempio

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

• Un bot con una sola lingua, inglese (GB) (en_GB) o inglese (US) (en_US).

• Un unico intento,. OrderBirthStone Assicurati che la funzione Usa una funzione Lambda per l'inizializzazione e la convalida sia selezionata nella sezione Code hook della definizione dell'intento.

• L'intento deve avere due slot, "BirthMonth" e «Name», entrambi di tipo. AMAZON.AlphaNumeric

• Un alias con la funzione Lambda definita. Per ulteriori informazioni, consulta Creazione e associazione di una funzione Lambda a un alias bot.

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 dell'API di gestione delle sessioni

Per utilizzare un intento diverso da quello corrente, usa l'PutSessionoperazione. 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 Gestione delle sessioni con l'API Amazon Lex V2.