Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Usa las puntuaciones de confianza en la transcripción de voz para mejorar las conversaciones con tu bot Lex V2

Cuando un usuario hace un enunciado de voz, Amazon Lex V2 utiliza el reconocimiento de voz automático (ASR) para transcribir la solicitud del usuario antes de interpretarla. De forma predeterminada, Amazon Lex V2 utiliza la transcripción más probable del audio para la interpretación.

En algunos casos, es posible que haya más de una transcripción del audio. Por ejemplo, un usuario puede hacer un enunciado con un sonido ambiguo, como «Me llamo John», que podría entenderse como «Me llamo Juan». En este caso, puede utilizar técnicas de desambiguación o combinar sus conocimientos del dominio con la puntuación de confianza de la transcripción para determinar qué transcripción de una lista de transcripciones es la correcta.

Amazon Lex V2 incluye la transcripción superior y hasta dos transcripciones alternativas para que el usuario las introduzca en la solicitud a la función de enlace de códigos de Lambda. Cada transcripción contiene una puntuación de confianza que indica que es la transcripción correcta. Cada transcripción también incluye cualquier valor de slot inferido de la entrada del usuario.

Puede comparar las puntuaciones de confianza de dos transcripciones para determinar si hay ambigüedad entre ellas. Por ejemplo, si una transcripción tiene una puntuación de confianza de 0,95 y la otra tiene una puntuación de confianza de 0,65, es probable que la primera transcripción sea correcta y que la ambigüedad entre ambas sea baja. Si las dos transcripciones tienen puntuaciones de confianza de 0,75 y 0,72, la ambigüedad entre ellas es alta. Es posible que pueda discriminar entre ellas utilizando sus conocimientos de dominio.

Por ejemplo, si los valores de slot inferidos en dos transcripciones con una puntuación de confianza de 0,75 y 0,72 son «John» y «Juan», puede consultar a los usuarios de su base de datos para comprobar la existencia de estos nombres y eliminar una de las transcripciones. Si «John» no es un usuario de la base de datos y «Juan» sí lo es, puede usar el enlace de códigos del diálogo para cambiar el valor de slot inferido para el nombre a «Juan».

Las puntuaciones de confianza que devuelve Amazon Lex V2 son valores comparativos. No confíe en ellas como puntuación absoluta. Los valores pueden cambiar en función de las mejoras de Amazon Lex V2.

Las puntuaciones de confianza en la transcripción de audio solo están disponibles en los idiomas inglés (GB) (en_GB) e inglés (US) (en_US). Las puntuaciones de confianza solo se admiten para 8 entradas kHz de audio. Las puntuaciones de confianza de la transcripción no se proporcionan para la entrada de audio desde la ventana de prueba de la consola Amazon Lex V2 porque utiliza 16 entradas de kHz audio.

Puede usar las puntuaciones de confianza para varios patrones de diseño de conversación:

Amazon Lex V2 envía la siguiente JSON estructura con hasta tres transcripciones para que el usuario introduzca en la función de enlace de código de 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 estructura contiene el texto de la transcripción, la intención que se resolvió para el enunciado y los valores de los espacios detectados en el enunciado. En cuanto al texto introducido por el usuario, las transcripciones contienen una sola transcripción con una puntuación de confianza de 1.0.

El contenido de las transcripciones depende del giro de la conversación y de la intención reconocida.

Para el primer turno, la obtención de intenciones, Amazon Lex V2 determina las tres transcripciones principales. En el caso de la transcripción superior, devuelve la intención y cualquier valor de slot inferido en la transcripción.

En los turnos subsiguientes, es decir, los resultados dependen de la intención inferida para cada una de las transcripciones, tal y como se indica a continuación.

Administración de sesiones

Para cambiar la intención que Amazon Lex V2 utiliza en una conversación con el usuario, utilice la respuesta del enlace de código del cuadro de diálogo (función de Lambda). O bien, puede usar la administración de sesiones APIs en su aplicación personalizada.

Uso de una función Lambda con el bot Lex V2

Cuando utiliza una función Lambda, Amazon Lex V2 la llama con una JSON estructura que contiene la entrada de la función. La JSON estructura contiene un campo denominado transcriptions que contiene las posibles transcripciones que Amazon Lex V2 ha determinado para el enunciado. El campo transcriptions contiene de una a tres posibles transcripciones, cada una con una puntuación de confianza.

Para utilizar la intención de una transcripción alternativa, debe especificarla en la ConfirmIntent o la acción de diálogo ElicitSlot de la función de Lambda. Para utilizar un valor de slot de una transcripción alternativa, defina el valor en el campo intent de la respuesta de la función de Lambda. Para obtener más información, consulte Integrar un AWS Lambda función en tu bot.

Ejemplo de código con Lambda con Lex V2

El siguiente ejemplo de código es una función de Lambda de Python que utiliza transcripciones de audio para mejorar la experiencia de conversación del usuario.

Para utilizar el código de ejemplo, debe disponer de lo siguiente:

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)

Utilizar la administración de sesiones API para elegir una intención o un valor de intervalo diferente

Para utilizar una intención diferente de la intención actual, utilice la PutSessionoperación. Por ejemplo, si decide que la primera alternativa es preferible a la intención que eligió Amazon Lex V2, puede utilizar la operación PutSession para cambiar las intenciones. De esta forma, la siguiente intención con la que interactúe el usuario será la que usted haya seleccionado.

También puede usar la operación PutSession para cambiar el valor del slot en la estructura intent y usar un valor de una transcripción alternativa.

Para obtener más información, consulte Descripción de las sesiones de bots de Amazon Lex V2.