Como usar pontuações de confiança na transcrição de voz

Quando um usuário faz um enunciado por voz, o Amazon Lex V2 usa o reconhecimento automático de fala (ASR) para transcrever a solicitação do usuário antes que ela seja interpretada. Por padrão, o Amazon Lex V2 usa a transcrição mais provável do áudio para interpretação.

Em alguns casos, pode haver mais de uma possível transcrição do áudio. Por exemplo, um usuário pode fazer um enunciado com um som ambíguo, como “Meu nome é John”, que pode ser entendido como “Meu nome é Juan”. Nesse caso, você pode usar técnicas de desambiguação ou combinar seu conhecimento de domínio com a pontuação de confiança da transcrição para ajudar a determinar qual transcrição é a correta em uma lista de transcrições.

O Amazon Lex V2 inclui a transcrição principal e até duas transcrições alternativas para a entrada do usuário na solicitação da função de hook de código Lambda. Cada transcrição contém uma pontuação de confiança que indica a probabilidade de ser a transcrição correta. Cada transcrição também inclui quaisquer valores de slot inferidos a partir da entrada do usuário.

Você pode comparar as pontuações de confiança de duas transcrições para determinar se há ambiguidade entre elas. Por exemplo, se uma transcrição tem uma pontuação de confiança de 0,95 e a outra tem uma pontuação de confiança de 0,65, a primeira transcrição provavelmente está correta e a ambiguidade entre elas é baixa. Se as duas transcrições tiverem pontuações de confiança de 0,75 e 0,72, a ambiguidade entre elas é alta. Talvez você consiga discriminá-las usando seu conhecimento de domínio.

Por exemplo, se os valores de slot inferidos em duas transcrições com uma pontuação de confiança de 0,75 e 0,72 forem “John” e “Juan”, você poderá consultar os usuários no banco de dados para verificar a existência desses nomes e eliminar uma das transcrições. Se “John” não for um usuário no banco de dados e “Juan” for, você poderá usar o hook de código de diálogo para alterar o valor do slot inferido para “Juan”, o primeiro nome.

As pontuações de confiança que o Amazon Lex V2 retorna são valores comparativos. Não confie nelas como uma pontuação absoluta. Os valores podem mudar com base em melhorias no Amazon Lex V2.

As pontuações de confiança da transcrição de áudio estão disponíveis somente nos idiomas inglês (GB) (en_GB) e inglês (EUA) (en_US). As pontuações de confiança são compatíveis somente com entradas de áudio de 8 kHz. As pontuações de confiança da transcrição não são fornecidas para entrada de áudio da janela de teste no console do Amazon Lex V2 porque ele usa entrada de áudio de 16 kHz.

nota

Antes de usar as pontuações de confiança da transcrição de áudio com um bot existente, é preciso primeiro reconstruir o bot. As versões existentes de um bot não oferecem suporte a pontuações de confiança na transcrição. É necessário criar uma nova versão do bot para usá-las.

Você pode usar pontuações de confiança para vários padrões de design de conversas:

• Se a pontuação de confiança mais alta cair abaixo de um limite devido a um ambiente ruidoso ou à baixa qualidade do sinal, você poderá solicitar que o usuário faça a mesma pergunta para capturar um áudio de melhor qualidade.

• Se várias transcrições tiverem pontuações de confiança semelhantes para valores de slot, como “John” e “Juan”, você poderá comparar os valores com um banco de dados preexistente para eliminar entradas ou solicitar que o usuário selecione um dos dois valores. Por exemplo, “diga 1 para John ou 2 para Juan”.

• Se a lógica de negócios exigir a troca de intenção com base em palavras-chave específicas em uma transcrição alternativa com uma pontuação de confiança próxima à transcrição principal, você poderá alterar a intenção usando a função do Lambda do hook de código de diálogo ou usando operações de gerenciamento de sessão. Para obter mais informações, consulte Gerenciamento de sessões.

O Amazon Lex V2 envia a seguinte estrutura JSON com até três transcrições para a entrada do usuário na função de hook de código 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"
                                ]
                            }
                        }
                    ]
                }
            }
        }
    ]
     

A estrutura JSON contém texto de transcrição, a intenção que foi identificada para o enunciado e valores para quaisquer slots detectados no enunciado. Para a entrada de texto do usuário, as transcrições contêm uma única transcrição com uma pontuação de confiança de 1,0.

O conteúdo das transcrições depende do rumo da conversa e da intenção reconhecida.

Na primeira etapa, a escolha da intenção, o Amazon Lex V2 determina as três principais transcrições. Para a transcrição principal, ele retorna a intenção e quaisquer valores de slot inferidos na transcrição.

Nas etapas subsequentes, na escolha de slots, os resultados dependem da intenção inferida para cada uma das transcrições, conforme a seguir.

• Se a intenção inferida para a transcrição principal for a mesma da etapa anterior e todas as outras transcrições tiverem a mesma intenção, então:

  • Todas as transcrições contêm valores de slot inferidos.

     

• Se a intenção inferida para a transcrição principal for diferente da etapa anterior e todas as outras transcrições tiverem a mesma intenção, então:

  • A transcrição principal contém os valores de slot inferidos para a nova intenção.

  • As outras transcrições contêm a intenção anterior e valores de slot inferidos para ela.

     

• Se a intenção inferida para a transcrição principal for diferente da etapa anterior, uma transcrição for igual à intenção anterior e uma transcrição tiver uma intenção diferente, então

  • A transcrição principal contém a nova intenção inferida e quaisquer valores de slot inferidos no enunciado.

  • A transcrição que tem a intenção inferida anterior contém valores de slot inferidos para essa intenção.

  • A transcrição com a intenção diferente não possui um nome de intenção inferida nem valores de slot inferidos.

     

• Se a intenção inferida para a transcrição principal for diferente da etapa anterior e todas as outras transcrições tiverem intenções diferentes, então:

  • A transcrição principal contém a nova intenção inferida e quaisquer valores de slot inferidos no enunciado.

  • Outras transcrições não contêm intenções inferidas nem valores de slots inferidos.

     

• Se a intenção inferida para as duas transcrições principais for a mesma e diferente da etapa anterior, e a terceira transcrição tiver uma intenção diferente, então:

  • As duas transcrições principais contêm a nova intenção inferida e quaisquer valores de slot inferidos no enunciado.

  • A terceira transcrição não tem nome de intenção nem valores de slot resolvidos.

Gerenciamento de sessões

Para alterar a intenção que o Amazon Lex V2 usa em uma conversa com o usuário, use a resposta da função do Lambda do hook de código de diálogo. Ou você pode usar as APIs de gerenciamento de sessão no aplicativo personalizado.

Usar uma função do Lambda

Quando você usa uma função do Lambda, o Amazon Lex V2 a chama com uma estrutura JSON que contém a entrada para a função. A estrutura JSON contém um campo chamado transcriptions que contém as possíveis transcrições que o Amazon Lex V2 determinou para o enunciado. O campo transcriptions contém de uma a três transcrições possíveis, cada uma com uma pontuação de confiança.

Para usar a intenção de uma transcrição alternativa, especifique-a na ação de diálogo ConfirmIntent ou ElicitSlot na função do Lambda. Para usar um valor de slot de uma transcrição alternativa, defina o valor no campo intent na resposta da função do Lambda. Para obter mais informações, consulte Habilitando a lógica personalizada com as funções do AWS Lambda.

Código de exemplo

O exemplo de código a seguir é uma função do Lambda em Python que usa transcrições de áudio para melhorar a experiência de conversação do usuário.

Para usar o código de exemplo, é necessário ter:

• Um bot com um idioma, inglês (GB) (en_GB) ou inglês (EUA) (en_US).

• Uma intenção, OrderBirthStone. Certifique-se de que a opção Usar uma função do Lambda para inicialização e validação esteja selecionada na seção Hooks de código da definição da intenção.

• A intenção deve ter dois slots, “BirthMonth” e “Name”, ambos do tipo AMAZON.AlphaNumeric.

• Um alias com a função do Lambda definida. Para obter mais informações, consulte Criar e anexar uma função do Lambda a um alias de 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)

Usar a API de gerenciamento de sessões

Para usar uma intenção diferente da intenção atual, use a operação PutSession. Por exemplo, se você decidir que a primeira alternativa é preferível à intenção escolhida pelo Amazon Lex V2, use a operação PutSession para alterar as intenções. Dessa forma, a próxima intenção com a qual o usuário interagirá será aquela que você selecionou.

Você também pode usar a operação PutSession para alterar o valor do slot na estrutura intent para usar um valor de uma transcrição alternativa.

Para obter mais informações, consulte Gerenciamento de sessões com a API Amazon Lex V2.