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

Quando um usuário faz uma declaração de 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 transcrição possível do áudio. Por exemplo, um usuário pode fazer uma declaração 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 em uma lista de transcrições é a correta.

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

Você pode comparar as pontuações de confiança de duas transcrições para determinar se há ambigüidade 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 ambigüidade entre elas é baixa. Se as duas transcrições tiverem escores de confiança de 0,75 e 0,72, a ambigüidade entre elas é alta. Você pode discriminar entre eles usando seu conhecimento de domínio.

Por exemplo, se os valores dos slots 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 em seu banco de dados para verificar a existência desses nomes e eliminar uma das transcrições. Se “John” não for um usuário em seu banco de dados e “Juan” for, você pode usar o gancho do código de diálogo para alterar o valor do slot inferido para o primeiro nome para “Juan”.

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

As pontuações de confiança na 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 suportadas somente para entrada de áudio de 8 kHz. As pontuações de confiança de transcrição não são fornecidas para entrada de áudio da janela de teste no console Amazon Lex V2 porque ela 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, você deve primeiro reconstruir o bot. As versões existentes de um bot não oferecem suporte às pontuações de confiança na transcrição. É necessário criar uma nova versão do bot para usá-los.

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

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

• Se várias transcrições tiverem pontuações de confiança semelhantes para valores de slots, 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 João ou diga 2 para Juan”.

• Se sua 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 superior, você poderá alterar a intenção usando sua função Lambda de gancho 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 em sua função de gancho de código do Lambda:

    "transcriptions": [
        {
            "transcription": "string",
            "transcriptionConfidence": {
                "score": "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 o texto da transcrição, a intenção que foi resolvida para o enunciado e valores para qualquer espaço detectado no enunciado. Para entrada de texto pelo 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.

No primeiro turno, elicitação de intenção, o Amazon Lex V2 determina as três principais transcrições. Para a transcrição superior, ele retorna a intenção e quaisquer valores de slot inferidos na transcrição.

Nos turnos subsequentes, elicitação por fenda, os resultados dependem da intenção inferida para cada uma das transcrições, conforme segue.

• Se a intenção inferida para a transcrição superior for a mesma do turno 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 superior for diferente da curva anterior e todas as outras transcrições tiverem a intenção anterior, então

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

  • Outras transcrições têm a intenção anterior e valores de slot inferidos para a intenção anterior.

     

• Se a intenção inferida para a transcrição superior for diferente do turno anterior, uma transcrição é igual à intenção anterior e uma transcrição é uma intenção diferente, então

  • A transcrição superior 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 tem nome de intenção inferido nem valores de slot inferidos.

     

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

  • A transcrição superior 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 slot inferidos.

     

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

  • As duas principais transcrições 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 sua função Lambda de gancho de código de diálogo. Ou você pode usar as APIs de gerenciamento de sessão em seu aplicativo personalizado.

Usar uma função do Lambda

Quando você usa uma função 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 chamadotranscriptions que contém as possíveis transcrições que o Amazon Lex V2 determinou para o enunciado. Otranscriptions campo 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, você a especifica na açãoConfirmIntent ou naElicitSlot caixa de diálogo em sua função Lambda. Para usar um valor de slot de uma transcrição alternativa, defina o valor nointent campo na resposta da função Lambda. Para obter mais informações, consulte Usando umaAWS Lambda função.

Código de exemplo

O exemplo de código a seguir é uma função Python Lambda 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 Lambda para inicialização e validação esteja selecionada na seção Ganchos de código da definição de intenção.

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

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

Usando a API de gerenciamento de sessão

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

Você também pode usar aPutSession operação para alterar o valor do slot naintent estrutura para usar um valor de uma transcrição alternativa.

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