Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Utiliser les scores de fiabilité de la transcription vocale pour améliorer les conversations avec votre robot Lex V2

Lorsqu'un utilisateur émet un énoncé vocal, Amazon Lex V2 utilise la reconnaissance vocale automatique (ASR) pour transcrire la demande de l'utilisateur avant qu'elle ne soit interprétée. Par défaut, Amazon Lex V2 utilise la transcription la plus probable de l'audio à des fins d'interprétation.

Dans certains cas, il peut y avoir plusieurs transcriptions possibles de l'audio. Par exemple, un utilisateur peut émettre un énoncé avec un son ambigu, tel que « Je m'appelle John », qui peut être compris comme « Je m'appelle Juan ». Dans ce cas, vous pouvez utiliser des techniques de désambiguïsation ou combiner vos connaissances du domaine avec le score de confiance de la transcription pour déterminer quelle transcription d'une liste de transcriptions est la bonne.

Amazon Lex V2 inclut la transcription supérieure et jusqu'à deux transcriptions alternatives pour la saisie par l'utilisateur dans la demande adressée à votre fonction de crochet de code Lambda. Chaque transcription contient un score de confiance indiquant qu'il s'agit de la bonne transcription. Chaque transcription inclut également toutes les valeurs de créneau déduites de l'entrée de l'utilisateur.

Vous pouvez comparer les scores de confiance de deux transcriptions pour déterminer s'il existe une ambiguïté entre elles. Par exemple, si une transcription a un score de confiance de 0,95 et l'autre un score de confiance de 0,65, la première transcription est probablement correcte et l'ambiguïté entre les deux est faible. Si les deux transcriptions ont des scores de confiance de 0,75 et 0,72, l'ambiguïté entre elles est élevée. Vous pourrez peut-être les différencier en utilisant vos connaissances du domaine.

Par exemple, si les valeurs de créneau déduites dans deux transcriptions avec un score de confiance de 0,75 et 0,72 sont « John » et « Juan », vous pouvez demander aux utilisateurs de votre base de données l'existence de ces noms et éliminer l'une des transcriptions. Si « John » n'est pas un utilisateur dans votre base de données et que « Juan » l'est, vous pouvez utiliser le crochet de dialogue pour remplacer la valeur d'emplacement déduite du prénom par « Juan ».

Les scores de confiance renvoyés par Amazon Lex V2 sont des valeurs comparatives. Ne les considérez pas comme un score absolu. Les valeurs peuvent changer en fonction des améliorations apportées à Amazon Lex V2.

Les scores de fiabilité de la transcription audio ne sont disponibles qu'en anglais (GB) (en_GB) et en anglais (US) (en_US). Les scores de confiance ne sont pris en charge que pour 8 entrées kHz audio. Les scores de fiabilité de la transcription ne sont pas fournis pour les entrées audio provenant de la fenêtre de test sur la console Amazon Lex V2, car celle-ci utilise 16 entrées kHz audio.

Vous pouvez utiliser les scores de confiance pour plusieurs modèles de conception de conversation :

Amazon Lex V2 envoie la JSON structure suivante avec jusqu'à trois transcriptions pour la saisie par l'utilisateur de votre fonction de crochet de code 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 structure contient le texte de transcription, l'intention qui a été résolue pour l'énoncé et les valeurs de tous les intervalles détectés dans l'énoncé. Pour la saisie de texte par l'utilisateur, les transcriptions contiennent une seule transcription avec un score de confiance de 1,0.

Le contenu des transcriptions dépend de la tournure de la conversation et de l'intention reconnue.

Pour le premier tour, l'obtention d'une intention, Amazon Lex V2 détermine les trois meilleures transcriptions. Pour la transcription supérieure, elle renvoie l'intention et toutes les valeurs de créneau déduites dans la transcription.

Lors des tours suivants, lors de l'élicitation des créneaux, les résultats dépendent de l'intention déduite pour chacune des transcriptions, comme suit.

Gestion de session

Pour modifier l'intention utilisée par Amazon Lex V2 lors d'une conversation avec l'utilisateur, utilisez la réponse de la fonction Lambda de votre crochet de dialogue. Vous pouvez également utiliser la gestion de session APIs dans votre application personnalisée.

Utilisation d'une fonction Lambda avec votre bot Lex V2

Lorsque vous utilisez une fonction Lambda, Amazon Lex V2 l'appelle avec une JSON structure qui contient l'entrée de la fonction. La JSON structure contient un champ appelé transcriptions qui contient les transcriptions possibles déterminées par Amazon Lex V2 pour l'énoncé. Le transcriptions champ contient une à trois transcriptions possibles, chacune avec un score de confiance.

Pour utiliser l'intention d'une autre transcription, vous devez la spécifier dans l'action ConfirmIntent ou dans la ElicitSlot boîte de dialogue de votre fonction Lambda. Pour utiliser une valeur de slot issue d'une transcription alternative, définissez la valeur dans le intent champ de réponse de votre fonction Lambda. Pour de plus amples informations, veuillez consulter Intégrer un AWS Lambda fonctionne dans votre bot.

Exemple de code utilisant Lambda avec Lex V2

L'exemple de code suivant est une fonction Lambda en Python qui utilise des transcriptions audio pour améliorer l'expérience de conversation de l'utilisateur.

Pour utiliser l'exemple de code, vous devez avoir :

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)

Utilisation de la gestion de session API pour choisir une intention ou une valeur d'intervalle différente

Pour utiliser une intention différente de l'intention actuelle, utilisez l'PutSessionopération. Par exemple, si vous décidez que la première alternative est préférable à l'intention choisie par Amazon Lex V2, vous pouvez utiliser l'PutSessionopération pour modifier les intentions. Ainsi, l'intention suivante avec laquelle l'utilisateur interagira sera celle que vous avez sélectionnée.

Vous pouvez également utiliser cette PutSession opération pour modifier la valeur du slot dans la intent structure afin d'utiliser une valeur provenant d'une autre transcription.

Pour de plus amples informations, veuillez consulter Comprendre les sessions de bot Amazon Lex V2.