Exploration de l’IA générative dans les expériences conversationnelles une introduction avec Amazon Lex, Langchain et SageMaker Jumpstart.

Introduction to generative AI in conversational experiences with Amazon Lex, Langchain, and SageMaker Jumpstart.

Les clients s’attendent à un service rapide et efficace de la part des entreprises dans le monde actuel où tout va vite. Cependant, fournir un excellent service client peut être considérablement difficile lorsque le volume de demandes dépasse les ressources humaines employées pour y répondre. Cependant, les entreprises peuvent relever ce défi tout en fournissant un service client personnalisé et efficace grâce aux avancées de l’intelligence artificielle générative (IA générative) alimentée par de grands modèles de langage (LLM).

Les chatbots d’IA générative ont acquis une notoriété pour leur capacité à imiter l’intelligence humaine. Cependant, contrairement aux bots orientés tâches, ces bots utilisent des LLM pour l’analyse de texte et la génération de contenu. Les LLM sont basés sur l’architecture Transformer, un réseau de neurones d’apprentissage en profondeur introduit en juin 2017 qui peut être entraîné sur un corpus massif de texte non étiqueté. Cette approche crée une expérience de conversation plus humaine et peut aborder plusieurs sujets.

Au moment de la rédaction de ces lignes, des entreprises de toutes tailles veulent utiliser cette technologie mais ont besoin d’aide pour savoir par où commencer. Si vous cherchez à vous lancer dans l’IA générative et l’utilisation de LLM dans l’IA conversationnelle, ce post est pour vous. Nous avons inclus un projet d’exemple pour déployer rapidement un bot Amazon Lex qui consomme un LLM open-source pré-entraîné. Le code comprend également le point de départ pour implémenter un gestionnaire de mémoire personnalisé. Ce mécanisme permet à un LLM de se rappeler les interactions précédentes pour maintenir le contexte et le rythme de la conversation. Enfin, il est essentiel de souligner l’importance d’expérimenter avec les paramètres de prompts de réglage fin et de la détermination et du hasard de LLM pour obtenir des résultats cohérents.

Aperçu de la solution

La solution intègre un bot Amazon Lex avec un LLM open-source populaire de Amazon SageMaker JumpStart, accessible via un point de terminaison Amazon SageMaker. Nous utilisons également LangChain, un framework populaire qui simplifie les applications alimentées par LLM. Enfin, nous utilisons un QnABot pour fournir une interface utilisateur pour notre chatbot.

• Commencez avec la distribution open-source Amazon SageMaker
• Hébergez des modèles ML sur Amazon SageMaker en utilisant Triton Modèles ONNX
• Affinez GPT-J en utilisant un estimateur Amazon SageMaker Hugging Face et la bibliothèque de parallélisation de modèle.

Tout d’abord, nous commençons par décrire chaque composant dans le diagramme précédent :

• JumpStart offre des modèles open-source pré-entraînés pour différents types de problèmes. Cela vous permet de commencer l’apprentissage automatique (ML) rapidement. Il comprend le modèle FLAN-T5-XL, un LLM déployé dans un conteneur d’apprentissage en profondeur. Il fonctionne bien sur diverses tâches de traitement du langage naturel (NLP), y compris la génération de texte.
• Un point de terminaison d’inférence en temps réel SageMaker permet un déploiement rapide et évolutif de modèles ML pour prédire des événements. Avec la possibilité de s’intégrer à des fonctions Lambda, le point de terminaison permet la création d’applications personnalisées.
• La fonction AWS Lambda utilise les demandes du bot Amazon Lex ou du QnABot pour préparer la charge utile pour invoquer le point de terminaison SageMaker en utilisant LangChain. LangChain est un framework qui permet aux développeurs de créer des applications alimentées par LLM.
• Le bot Amazon Lex V2 a le type d’intention AMAZON.FallbackIntent intégré. Il est déclenché lorsque l’entrée de l’utilisateur ne correspond à aucune intention dans le bot.
• Le QnABot est une solution AWS open-source pour fournir une interface utilisateur aux bots Amazon Lex. Nous l’avons configuré avec une fonction d’accrochage Lambda pour un élément CustomNoMatches, et il déclenche la fonction Lambda lorsque QnABot ne peut pas trouver de réponse. Nous supposons que vous l’avez déjà déployé et inclus les étapes de configuration dans les sections suivantes.

La solution est décrite à un niveau élevé dans le diagramme de séquence suivant.

Tâches principales effectuées par la solution

Dans cette section, nous examinons les principales tâches effectuées dans notre solution. Le code source complet de ce projet est disponible pour votre référence dans ce référentiel GitHub.

Gestion des échecs du chatbot

La fonction Lambda gère les réponses “je ne sais pas” via AMAZON.FallbackIntent dans Amazon Lex V2 et l’élément CustomNoMatches dans QnABot. Lorsqu’elle est déclenchée, cette fonction examine la demande pour une session et l’intention de secours. S’il y a correspondance, il transfère la demande à un dispatcher Lex V2; sinon, le dispatcher QnABot utilise la demande. Voir le code suivant:

def dispatch_lexv2(request):
    """Résumé
    Args:
        request (dict): Événement Lambda contenant le message de chat d'entrée de l'utilisateur et le contexte (conversation historique)
        Utilise l'API de sessions LexV2 pour gérer les entrées passées https://docs.aws.amazon.com/lexv2/latest/dg/using-sessions.html
    
    Returns:
        dict: Description
    """
    lexv2_dispatcher = LexV2SMLangchainDispatcher(request)
    return lexv2_dispatcher.dispatch_intent()

def dispatch_QnABot(request):
    """Résumé
    
    Args:
        request (dict): Événement Lambda contenant le message de chat d'entrée de l'utilisateur et le contexte (conversation historique)
    
    Returns:
        dict: Dict formaté comme documenté pour être un crochet lambda pour une réponse "ne sais pas" pour le QnABot sur AWS Solution
        voir https://docs.aws.amazon.com/solutions/latest/QnABot-on-aws/specifying-lambda-hook-functions.html
    """
    request['res']['message'] = "Bonjour ! C'est votre Hook Python personnalisé qui parle !"
    qna_intent_dispatcher = QnASMLangchainDispatcher(request)
    return qna_intent_dispatcher.dispatch_intent()

def lambda_handler(event, context):
    print(event)
    if 'sessionState' in event:
        if 'intent' in event['sessionState']:
            if 'name' in event['sessionState']['intent']:
                if event['sessionState']['intent']['name'] == 'FallbackIntent':
                    return dispatch_lexv2(event)
    else:
        return dispatch_QnABot(event)

Fournir de la mémoire à notre LLM

Pour préserver la mémoire de LLM dans une conversation à plusieurs tours, la fonction Lambda comprend un mécanisme de classe de mémoire personnalisé LangChain qui utilise l’API de sessions Amazon Lex V2 pour suivre les attributs de session avec les messages de conversation à plusieurs tours en cours et pour fournir un contexte au modèle conversationnel via des interactions précédentes. Voir le code suivant :

class LexConversationalMemory(BaseMemory, BaseModel):

    """Classe de mémoire personnalisée Langchain qui utilise l'historique de conversation Lex
    
    Attributes:
        history (dict): Dictionnaire stockant l'historique de conversation qui agit comme mémoire Langchain
        lex_conv_context (str): L'API de sessions LexV2 qui sert d'entrée pour l'historique de conversation
            La mémoire est chargée à partir d'ici
        memory_key (str): clé pour la variable de mémoire Langchain de l'historique de chat - "history"
    """
    history = {}
    memory_key = "chat_history" #pass into prompt with key
    lex_conv_context = ""

    def clear(self):
        """Effacer l'historique de chat
        """
        self.history = {}

    @property
    def memory_variables(self) -> List[str]:
        """Charger les variables de mémoire
        
        Returns:
            List[str]: Liste des clés contenant la mémoire Langchain
        """
        return [self.memory_key]

    def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, str]:
        """Charger la mémoire à partir de lex dans la mémoire de session Langchain actuelle
        
        Args:
            inputs (Dict[str, Any]): Entrée utilisateur pour la session Langchain actuelle
        
        Returns:
            Dict[str, str]: Objet de mémoire Langchain
        """
        input_text = inputs[list(inputs.keys())[0]]

        ccontext = json.loads(self.lex_conv_context)
        memory = {
            self.memory_key: ccontext[self.memory_key] + input_text + "\nAI: ",
        }
        return memory

Le code suivant est l’exemple de code que nous avons créé pour introduire la classe de mémoire personnalisée dans une ConversationChain LangChain :

# Créer une chaîne de conversation en utilisant le prompt, 
# llm hébergé dans Sagemaker, et la classe de mémoire personnalisée
self.chain = ConversationChain(
    llm=sm_flant5_llm,
    prompt=prompt,
    memory=LexConversationalMemory(lex_conv_context=lex_conv_history),
    verbose=True
)

Définition de prompt

Un prompt pour un LLM est une question ou une déclaration qui donne le ton pour la réponse générée. Les prompts fonctionnent comme une forme de contexte qui aide à diriger le modèle vers la génération de réponses pertinentes. Voir le code suivant :

# définir le prompt
prompt_template = """La conversation suivante est une conversation amicale entre un humain et une IA. L'IA est 
bavarde et fournit beaucoup de détails spécifiques de son contexte. Si l'IA ne sait pas 
la réponse à une question, elle dit honnêtement qu'elle ne sait pas. Vous disposez d'informations
sur les entités mentionnées par l'humain, le cas échéant.

Historique de chat :
{chat_history}

Conversation :
Humain : {input}
IA :"""

Utilisation d’une session Amazon Lex V2 pour le support de la mémoire LLM

Amazon Lex V2 initie une session lorsqu’un utilisateur interagit avec un bot. Une session persiste dans le temps sauf si elle est arrêtée manuellement ou expirée. Une session stocke des métadonnées et des données spécifiques à l’application appelées attributs de session. Amazon Lex met à jour les applications clientes lorsque la fonction Lambda ajoute ou modifie des attributs de session. QnABot inclut une interface pour définir et obtenir des attributs de session sur Amazon Lex V2.

Dans notre code, nous avons utilisé ce mécanisme pour construire une classe mémoire personnalisée dans LangChain afin de suivre l’historique de la conversation et permettre à LLM de rappeler des interactions à court et à long terme. Voir le code suivant:

class LexV2SMLangchainDispatcher():

    def __init__(self, intent_request):
        # Voir le format d'entrée de bot Lex pour lambda https://docs.aws.amazon.com/lex/latest/dg/lambda-input-response-format.html
        self.intent_request = intent_request
        self.localeId = self.intent_request['bot']['localeId']
        self.input_transcript = self.intent_request['inputTranscript'] # entrée utilisateur
        self.session_attributes = utils.get_session_attributes(
            self.intent_request)
        self.fulfillment_state = "Fulfilled"
        self.text = "" # réponse de point final
        self.message = {'contentType': 'PlainText','content': self.text}

class QnABotSMLangchainDispatcher():
    def __init__(self, intent_request):
        # Attributs de session QnABot
        self.intent_request = intent_request
        self.input_transcript = self.intent_request['req']['question']
        self.intent_name = self.intent_request['req']['intentname']
        self.session_attributes = self.intent_request['req']['session']

Prérequis

Pour commencer le déploiement, vous devez remplir les prérequis suivants:

• Accès à la console de gestion AWS via un utilisateur qui peut lancer des piles AWS CloudFormation
• Connaissance de la navigation dans les consoles Lambda et Amazon Lex

Déployer la solution

Pour déployer la solution, procédez comme suit:

1. Choisissez Lancer la pile pour lancer la solution dans la région us-east-1:
2. Pour Nom de la pile, entrez un nom de pile unique.
3. Pour HFModel, nous utilisons le modèle Hugging Face Flan-T5-XL disponible sur JumpStart.
4. Pour HFTask, entrez text2text.
5. Laissez Nom du bucket S3 tel quel.

Ceci est utilisé pour trouver les ressources Amazon Simple Storage Service (Amazon S3) nécessaires au déploiement de la solution et peut changer lorsque des mises à jour sont publiées.

1. Reconnaître les capacités.
2. Choisissez Créer la pile.

Il devrait y avoir quatre piles créées avec succès.

Configurer le bot Amazon Lex V2

Il n’y a rien à faire avec le bot Amazon Lex V2. Notre modèle CloudFormation a déjà fait le gros du travail.

Configurer QnABot

Nous supposons que vous avez déjà déployé un QnABot existant dans votre environnement. Mais si vous avez besoin d’aide, suivez ces instructions pour le déployer.

1. Sur la console AWS CloudFormation, accédez à la pile principale que vous avez déployée.
2. Dans l’onglet Sorties, prenez note de LambdaHookFunctionArn car vous devez l’insérer dans QnABot plus tard.

1. Connectez-vous à l’interface utilisateur (UI) QnABot Designer en tant qu’administrateur.
2. Dans l’interface utilisateur des questions, ajoutez une nouvelle question.

1. Entrez les valeurs suivantes :
   • ID – CustomNoMatches
   • Question – no_hits
   • Réponse – Toute réponse par défaut pour “ne sais pas”
2. Choisissez Avancé et allez à la section Hook Lambda.
3. Entrez le nom de ressource Amazon (ARN) de la fonction Lambda que vous avez noté précédemment.

1. Faites défiler jusqu’en bas de la section et choisissez Créer.

Vous obtenez une fenêtre avec un message de réussite.

Votre question est maintenant visible sur la page Questions.

Tester la solution

Passons maintenant au test de la solution. Tout d’abord, il convient de mentionner que nous avons déployé le modèle FLAN-T5-XL fourni par JumpStart sans aucun réglage fin. Cela peut avoir une certaine imprévisibilité, entraînant de légères variations dans les réponses.

Tester avec un bot Amazon Lex V2

Cette section vous aide à tester l’intégration du bot Amazon Lex V2 avec la fonction Lambda qui appelle le LLM déployé dans le point de terminaison SageMaker.

1. Sur la console Amazon Lex, accédez au bot intitulé Sagemaker-Jumpstart-Flan-LLM-Fallback-Bot. Ce bot a été configuré pour appeler la fonction Lambda qui invoque le point de terminaison SageMaker hébergeant le LLM en tant qu’intention de secours lorsqu’aucune autre intention n’est concordante.
2. Choisissez Intentions dans le volet de navigation.

En haut à droite, un message indique que “English (US) n’a pas construit de changements”.

1. Choisissez Construire.
2. Attendez que cela se termine.

Enfin, vous obtenez un message de réussite, comme indiqué dans la capture d’écran suivante.

1. Choisissez Tester.

Une fenêtre de chat apparaît où vous pouvez interagir avec le modèle.

Nous vous recommandons d’explorer les intégrations intégrées entre les bots Amazon Lex et Amazon Connect. Et aussi, les plateformes de messagerie (Facebook, Slack, Twilio SMS) ou les centres de contact tiers en utilisant Amazon Chime SDK et Genesys Cloud, par exemple.

Tester avec une instance QnABot

Cette section teste l’intégration QnABot sur AWS avec la fonction Lambda qui appelle LLM déployé dans le point de terminaison SageMaker.

1. Ouvrez le menu Outils dans le coin supérieur gauche.

1. Choisissez Client QnABot.

1. Choisissez Se connecter en tant qu’administrateur.

1. Saisissez une question dans l’interface utilisateur.
2. Évaluez la réponse.

Nettoyer

Pour éviter des frais futurs, supprimez les ressources créées par notre solution en suivant ces étapes :

1. Sur la console AWS CloudFormation, sélectionnez la pile nommée SagemakerFlanLLMStack (ou le nom personnalisé que vous avez défini pour la pile).
2. Choisissez Supprimer.
3. Si vous avez déployé l’instance QnABot pour vos tests, sélectionnez la pile QnABot.
4. Choisissez Supprimer.

Conclusion

Dans ce post, nous avons exploré l’ajout de capacités de domaine ouvert à un bot orienté tâches qui achemine les demandes de l’utilisateur vers un modèle de langage large open source.

Nous vous encourageons à :

• Enregistrer l’historique des conversations dans un mécanisme de persistance externe. Par exemple, vous pouvez enregistrer l’historique des conversations dans Amazon DynamoDB ou un bucket S3 et le récupérer dans le hook de la fonction Lambda. De cette façon, vous n’avez pas besoin de vous fier à la gestion des attributs de session non persistants internes offerte par Amazon Lex.
• Expérimenter avec la synthèse – Dans les conversations multitours, il est utile de générer un résumé que vous pouvez utiliser dans vos invites pour ajouter du contexte et limiter l’utilisation de l’historique des conversations. Cela aide à élaguer la taille de session du bot et à maintenir la consommation de mémoire de la fonction Lambda faible.
• Expérimenter avec les variations d’invite – Modifiez la description d’invite originale qui correspond à vos objectifs expérimentaux.
• Adapter le modèle de langue pour des résultats optimaux – Vous pouvez le faire en affinant les paramètres avancés LLM tels que l’aléatoire (température) et la détermination (top_p) selon vos applications. Nous avons démontré une intégration d’échantillon en utilisant un modèle pré-entraîné avec des valeurs d’échantillon, mais amusez-vous à ajuster les valeurs pour vos cas d’utilisation.

Dans notre prochain post, nous prévoyons de vous aider à découvrir comment affiner les chatbots alimentés par LLM pré-entraînés avec vos propres données.

Expérimentez-vous avec des chatbots LLM sur AWS? Dites-nous-en plus dans les commentaires!

Ressources et références

• Code source compagnon pour cet article
• Guide du développeur Amazon Lex V2
• Bibliothèque de solutions AWS : QnABot sur AWS
• Génération de Texte à Texte avec les modèles FLAN T5
• LangChain – Construction d’applications avec des LLMs
• Exemples Amazon SageMaker avec Jumpstart Foundation Models
• Amazon BedRock – La manière la plus simple de construire et de mettre à l’échelle des applications d’IA générative avec des modèles fondamentaux
• Créez rapidement des applications d’IA générative à haute précision sur des données d’entreprise en utilisant Amazon Kendra, LangChain et de grands modèles de langage

We will continue to update IPGirl; if you have any questions or suggestions, please contact us!