Créez des applications de chatbot personnalisées à l'aide de modèles OpenChatkit sur Amazon SageMaker | Services Web Amazon

Les grands modèles de langage open source (LLM) sont devenus populaires, permettant aux chercheurs, développeurs et organisations d'accéder à ces modèles pour favoriser l'innovation et l'expérimentation. Cela encourage la collaboration de la communauté open source pour contribuer au développement et à l'amélioration des LLM. Les LLM open source assurent la transparence de l'architecture du modèle, du processus de formation et des données de formation, ce qui permet aux chercheurs de comprendre le fonctionnement du modèle, d'identifier les biais potentiels et de répondre aux préoccupations éthiques. Ces LLM open source démocratisent l'IA générative en mettant la technologie avancée de traitement du langage naturel (NLP) à la disposition d'un large éventail d'utilisateurs pour créer des applications métier critiques. GPT-NeoX, LLaMA, Alpaca, GPT4All, Vicuna, Dolly et OpenAssistant sont quelques-uns des LLM open source populaires.

Kit de chat ouvert est un LLM open source utilisé pour créer des applications de chatbot à usage général et spécialisées, publié par Together Computer en mars 2023 sous la licence Apache-2.0. Ce modèle permet aux développeurs d'avoir plus de contrôle sur le comportement du chatbot et de l'adapter à leurs applications spécifiques. OpenChatKit fournit un ensemble d'outils, un bot de base et des blocs de construction pour créer des chatbots puissants et entièrement personnalisés. Les composants clés sont les suivants :

• Un LLM réglé sur les instructions, affiné pour le chat du GPT-NeoX-20B d'EleutherAI avec plus de 43 millions d'instructions sur un calcul 100% négatif en carbone. Le GPT-NeoXT-Chat-Base-20B Le modèle est basé sur le modèle GPT-NeoX d'EleutherAI et est affiné avec des données axées sur les interactions de type dialogue.
• Recettes de personnalisation pour affiner le modèle afin d'obtenir une grande précision sur vos tâches.
• Un système de récupération extensible vous permettant d'augmenter les réponses des robots avec des informations provenant d'un référentiel de documents, d'une API ou d'une autre source d'informations de mise à jour en direct au moment de l'inférence.
• Un modèle de modération, affiné à partir de GPT-JT-6B, conçu pour filtrer les questions auxquelles le bot répond.

L'échelle et la taille croissantes des modèles d'apprentissage en profondeur présentent des obstacles pour déployer avec succès ces modèles dans des applications d'IA génératives. Pour répondre aux exigences de faible latence et de débit élevé, il devient essentiel d'employer des méthodes sophistiquées telles que le parallélisme de modèles et la quantification. Manquant de maîtrise dans l'application de ces méthodes, de nombreux utilisateurs rencontrent des difficultés pour initier l'hébergement de modèles conséquents pour des cas d'utilisation d'IA générative.

Dans cet article, nous montrons comment déployer des modèles OpenChatKit (GPT-NeoXT-Chat-Base-20B and GPT-JT-Moderation-6B) modèles sur Amazon Sage Maker en utilisant DJL Serving et des bibliothèques parallèles de modèles open source comme DeepSpeed ​​et Hugging Face Accelerate. Nous utilisons DJL Serving, qui est une solution de service de modèle universelle hautes performances alimentée par la bibliothèque Deep Java (DJL) qui est indépendante du langage de programmation. Nous démontrons comment la bibliothèque Hugging Face Accelerate simplifie le déploiement de grands modèles dans plusieurs GPU, réduisant ainsi la charge de l'exécution des LLM de manière distribuée. Commençons!

Système de récupération extensible

Un système de récupération extensible est l'un des composants clés d'OpenChatKit. Il vous permet de personnaliser la réponse du bot en fonction d'une base de connaissances de domaine fermée. Bien que les LLM soient capables de conserver des connaissances factuelles dans leurs paramètres de modèle et puissent atteindre des performances remarquables sur les tâches NLP en aval lorsqu'elles sont affinées, leur capacité à accéder et à prédire avec précision les connaissances du domaine fermé reste limitée. Par conséquent, lorsqu'ils sont confrontés à des tâches à forte intensité de connaissances, leurs performances souffrent de celles des architectures spécifiques aux tâches. Vous pouvez utiliser le système de récupération OpenChatKit pour augmenter les connaissances dans leurs réponses à partir de sources de connaissances externes telles que Wikipedia, les référentiels de documents, les API et d'autres sources d'informations.

Le système de récupération permet au chatbot d'accéder aux informations actuelles en obtenant des détails pertinents en réponse à une requête spécifique, fournissant ainsi le contexte nécessaire pour que le modèle génère des réponses. Pour illustrer la fonctionnalité de ce système de récupération, nous fournissons un support pour un index d'articles de Wikipédia et proposons un exemple de code démontrant comment invoquer une API de recherche Web pour la récupération d'informations. En suivant la documentation fournie, vous pouvez intégrer le système de récupération à n'importe quel ensemble de données ou API pendant le processus d'inférence, permettant au chatbot d'incorporer des données mises à jour dynamiquement dans ses réponses.

Modèle de modération

Les modèles de modération sont importants dans les applications de chatbot pour appliquer le filtrage de contenu, le contrôle de la qualité, la sécurité des utilisateurs et les raisons juridiques et de conformité. La modération est une tâche difficile et subjective, et dépend beaucoup du domaine de l'application chatbot. OpenChatKit fournit des outils pour modérer l'application chatbot et surveiller les invites de saisie de texte pour tout contenu inapproprié. Le modèle de modération fournit une bonne base de référence qui peut être adaptée et personnalisée à divers besoins.

OpenChatKit a un modèle de modération de 6 milliards de paramètres, GPT-JT-Moderation-6B, qui peut modérer le chatbot pour limiter les entrées aux sujets modérés. Bien que le modèle lui-même ait une certaine modération intégrée, TogetherComputer a formé un GPT-JT-Modération-6B modèle avec Ontocord.ai Ensemble de données de modération OIG. Ce modèle fonctionne parallèlement au chatbot principal pour vérifier que l'entrée de l'utilisateur et la réponse du bot ne contiennent pas de résultats inappropriés. Vous pouvez également l'utiliser pour détecter toute question hors domaine adressée au chatbot et la remplacer lorsque la question ne fait pas partie du domaine du chatbot.

Le diagramme suivant illustre le flux de travail OpenChatKit.

Cas d'utilisation du système de récupération extensible

Bien que nous puissions appliquer cette technique dans divers secteurs pour créer des applications d'IA génératives, nous discutons pour cet article de cas d'utilisation dans le secteur financier. La génération augmentée de récupération peut être utilisée dans la recherche financière pour générer automatiquement des rapports de recherche sur des entreprises, des industries ou des produits financiers spécifiques. En récupérant les informations pertinentes des bases de connaissances internes, des archives financières, des articles de presse et des documents de recherche, vous pouvez générer des rapports complets qui résument les informations clés, les mesures financières, les tendances du marché et les recommandations d'investissement. Vous pouvez utiliser cette solution pour surveiller et analyser les actualités financières, le sentiment du marché et les tendances.

Vue d'ensemble de la solution

Les étapes suivantes sont nécessaires pour créer un chatbot à l'aide de modèles OpenChatKit et les déployer sur SageMaker :

1. Télécharger la base de discussion GPT-NeoXT-Chat-Base-20B modéliser et empaqueter les artefacts de modèle à télécharger vers Service de stockage simple Amazon (Amazon S3).
2. Utilisez un conteneur d'inférence de grand modèle (LMI) SageMaker, configurez les propriétés et configurez le code d'inférence personnalisé pour déployer ce modèle.
3. Configurez les techniques parallèles de modèle et utilisez les bibliothèques d'optimisation d'inférence dans les propriétés de service DJL. Nous utiliserons Hugging Face Accelerate comme moteur pour le service DJL. De plus, nous définissons des configurations parallèles de tenseurs pour partitionner le modèle.
4. Créez un modèle SageMaker et une configuration de point de terminaison, puis déployez le point de terminaison SageMaker.

Vous pouvez suivre en exécutant le bloc-notes dans le GitHub repo.

Télécharger le modèle OpenChatKit

Tout d'abord, nous téléchargeons le modèle de base OpenChatKit. Nous utilisons huggingface_hub et utilise téléchargement_instantané pour télécharger le modèle, qui télécharge un référentiel entier à une révision donnée. Les téléchargements sont effectués simultanément pour accélérer le processus. Voir le code suivant :

from huggingface_hub import snapshot_download
from pathlib import Path
import os
# - This will download the model into the current directory where ever the jupyter notebook is running
local_model_path = Path("./openchatkit")
local_model_path.mkdir(exist_ok=True)
model_name = "togethercomputer/GPT-NeoXT-Chat-Base-20B"
# Only download pytorch checkpoint files
allow_patterns = ["*.json", "*.pt", "*.bin", "*.txt", "*.model"]
# - Leverage the snapshot library to donload the model since the model is stored in repository using LFS
chat_model_download_path = snapshot_download( repo_id=model_name,#A user or an organization name and a repo name cache_dir=local_model_path, #Path to the folder where cached files are stored. allow_patterns=allow_patterns, #only files matching at least one pattern are downloaded.
)

Propriétés de DJL Serving

Vous pouvez utiliser les conteneurs SageMaker LMI pour héberger de grands modèles d'IA générative avec un code d'inférence personnalisé sans fournir votre propre code d'inférence. Ceci est extrêmement utile lorsqu'il n'y a pas de prétraitement personnalisé des données d'entrée ou de post-traitement des prédictions du modèle. Vous pouvez également déployer un modèle à l'aide d'un code d'inférence personnalisé. Dans cet article, nous montrons comment déployer des modèles OpenChatKit avec un code d'inférence personnalisé.

SageMaker attend les artefacts du modèle au format tar. Nous créons chaque modèle OpenChatKit avec les fichiers suivants : serving.properties ainsi que model.py.

La serving.properties Le fichier de configuration indique à DJL Serving quelles bibliothèques de parallélisation de modèles et d'optimisation d'inférence vous souhaitez utiliser. Voici une liste des paramètres que nous utilisons dans ce fichier de configuration :

openchatkit/serving.properties
engine = Python
option.tensor_parallel_degree = 4
option.s3url = {{s3url}}

Celui-ci contient les paramètres suivants :

• moteur – Le moteur à utiliser par DJL.
• option.entryPoint – Le fichier ou module Python de point d'entrée. Cela devrait correspondre au moteur utilisé.
• option.s3url – Définissez ceci sur l'URI du compartiment S3 qui contient le modèle.
• option.modelid – Si vous souhaitez télécharger le modèle depuis huggingface.co, vous pouvez définir option.modelid à l'ID de modèle d'un modèle pré-entraîné hébergé dans un référentiel de modèles sur huggingface.co (https://huggingface.co/models). Le conteneur utilise cet ID de modèle pour télécharger le référentiel de modèles correspondant sur huggingface.co.
• option.tensor_parallel_degree – Définissez ceci sur le nombre de périphériques GPU sur lesquels DeepSpeed ​​doit partitionner le modèle. Ce paramètre contrôle également le nombre de travailleurs par modèle qui seront démarrés lors de l'exécution de DJL Serving. Par exemple, si nous avons une machine à 8 GPU et que nous créons huit partitions, nous aurons alors un travailleur par modèle pour répondre aux requêtes. Il est nécessaire d'ajuster le degré de parallélisme et d'identifier la valeur optimale pour une architecture de modèle et une plate-forme matérielle données. Nous appelons cette capacité parallélisme adapté à l'inférence.

Reportez-vous à Configurations et paramètres pour une liste exhaustive des options.

Modèles OpenChatKit

L'implémentation du modèle de base OpenChatKit contient les quatre fichiers suivants :

• modèle.py – Ce fichier implémente la logique de gestion du modèle principal OpenChatKit GPT-NeoX. Il reçoit la demande d'entrée d'inférence, charge le modèle, charge l'index Wikipedia et sert la réponse. Faire référence à model.py(partie créée du cahier) pour plus de détails. model.py utilise les classes de clés suivantes :
  • ServiceOpenChatKit - Cela gère la transmission des données entre le modèle GPT-NeoX, la recherche Faiss et l'objet de conversation. WikipediaIndex ainsi que Conversation les objets sont initialisés et les conversations de chat d'entrée sont envoyées à l'index pour rechercher le contenu pertinent de Wikipedia. Cela génère également un ID unique pour chaque appel si aucun n'est fourni dans le but de stocker les invites dans Amazon DynamoDB.
  • ChatModèle – Cette classe charge le modèle et le tokenizer et génère la réponse. Il gère le partitionnement du modèle sur plusieurs GPU à l'aide tensor_parallel_degree, et configure le dtypes ainsi que device_map. Les invites sont transmises au modèle pour générer des réponses. Un critère d'arrêt StopWordsCriteria est configuré pour que la génération produise uniquement la réponse du bot lors de l'inférence.
  • ModérationModèle – Nous utilisons deux modèles de modération dans ModerationModel class : le modèle d'entrée pour indiquer au modèle de chat que l'entrée est inappropriée pour remplacer le résultat d'inférence, et le modèle de sortie pour remplacer le résultat d'inférence. Nous classons l'invite d'entrée et la réponse de sortie avec les étiquettes possibles suivantes :
    • occasionnel
    • a besoin de prudence
    • nécessite une intervention (ceci est signalé comme étant modéré par le modèle)
    • a peut-être besoin de prudence
    • a probablement besoin de prudence
• wikipedia_prepare.py – Ce fichier gère le téléchargement et la préparation de l'index Wikipedia. Dans cet article, nous utilisons un index Wikipedia fourni sur les jeux de données Hugging Face. Pour rechercher dans les documents Wikipédia du texte pertinent, l'index doit être téléchargé à partir de Hugging Face car il n'est pas emballé ailleurs. Le wikipedia_prepare.py Le fichier est responsable de la gestion du téléchargement lors de son importation. Un seul processus parmi les multiples qui s'exécutent pour l'inférence peut cloner le référentiel. Les autres attendent que les fichiers soient présents dans le système de fichiers local.
• wikipedia.py – Ce fichier est utilisé pour rechercher dans l'index Wikipedia des documents contextuellement pertinents. La requête d'entrée est tokenisée et les intégrations sont créées à l'aide de mean_pooling. Nous calculons des métriques de distance de similarité cosinus entre l'intégration de la requête et l'index Wikipédia pour récupérer des phrases Wikipédia contextuellement pertinentes. Faire référence à wikipedia.py pour les détails de mise en œuvre.

#function to create sentence embedding using mean_pooling
def mean_pooling(token_embeddings, mask): token_embeddings = token_embeddings.masked_fill(~mask[..., None].bool(), 0.0) sentence_embeddings = token_embeddings.sum(dim=1) / mask.sum(dim=1)[..., None] return sentence_embeddings #function to compute cosine similarity distance between 2 embeddings def cos_sim_2d(x, y): norm_x = x / np.linalg.norm(x, axis=1, keepdims=True) norm_y = y / np.linalg.norm(y, axis=1, keepdims=True) return np.matmul(norm_x, norm_y.T)

• conversation.py – Ce fichier est utilisé pour stocker et récupérer le fil de conversation dans DynamoDB pour le transmettre au modèle et à l'utilisateur. conversation.py est adapté du référentiel open-source OpenChatKit. Ce fichier est chargé de définir l'objet qui stocke les tours de conversation entre l'humain et le modèle. Avec cela, le modèle est capable de conserver une session pour la conversation, permettant à un utilisateur de se référer aux messages précédents. Étant donné que les appels de point de terminaison SageMaker sont sans état, cette conversation doit être stockée dans un emplacement externe aux instances de point de terminaison. Au démarrage, l'instance crée une table DynamoDB si elle n'existe pas. Toutes les mises à jour de la conversation sont ensuite stockées dans DynamoDB en fonction du session_id clé, qui est générée par le point de terminaison. Toute invocation avec un ID de session récupère la chaîne de conversation associée et la met à jour si nécessaire.

Créer un conteneur d'inférence LMI avec des dépendances personnalisées

La recherche d'index utilise Facebook Fayss bibliothèque pour effectuer la recherche de similarité. Comme cela n'est pas inclus dans l'image LMI de base, le conteneur doit être adapté pour installer cette bibliothèque. Le code suivant définit un Dockerfile qui installe Faiss à partir de la source aux côtés d'autres bibliothèques nécessaires au point de terminaison du bot. Nous utilisons le sm-docker utilitaire pour construire et pousser l'image vers Registre des conteneurs élastiques Amazon (Amazon ECR) de Amazon SageMakerStudio. Faire référence à Utilisation de l'interface de ligne de commande Amazon SageMaker Studio Image Build pour créer des images de conteneur à partir de vos blocs-notes Studio pour plus de détails.

Le conteneur DJL n'a pas installé Conda, donc Faiss doit être cloné et compilé à partir de la source. Pour installer Faiss, les dépendances permettant d'utiliser les API BLAS et le support Python doivent être installées. Une fois ces packages installés, Faiss est configuré pour utiliser AVX2 et CUDA avant d'être compilé avec les extensions Python installées.

pandas, fastparquet, boto3et une git-lfs sont installés par la suite car ils sont nécessaires au téléchargement et à la lecture des fichiers d'index.

FROM 763104351884.dkr.ecr.us-east-1.amazonaws.com/djl-inference:0.21.0-deepspeed0.8.0-cu117
ARG FAISS_URL=https://github.com/facebookresearch/faiss.git
RUN apt-get update && apt-get install -y git-lfs wget cmake pkg-config build-essential apt-utils
RUN apt search openblas && apt-get install -y libopenblas-dev swig
RUN git clone $FAISS_URL && cd faiss && cmake -B build . -DFAISS_OPT_LEVEL=avx2 -DCMAKE_CUDA_ARCHITECTURES="86" && make -C build -j faiss && make -C build -j swigfaiss && make -C build -j swigfaiss_avx2 && (cd build/faiss/python && python -m pip install ) RUN pip install pandas fastparquet boto3 && git lfs install --skip-repo && apt-get clean all

Créer le modèle

Maintenant que nous avons l'image Docker dans Amazon ECR, nous pouvons procéder à la création de l'objet modèle SageMaker pour les modèles OpenChatKit. Nous déployons GPT-NeoXT-Chat-Base-20B modèles de modération d'entrée et de sortie utilisant GPT-JT-Moderation-6B. Faire référence à créer_modèle pour plus de détails.

from sagemaker.utils import name_from_base chat_model_name = name_from_base(f"gpt-neoxt-chatbase-ds")
print(chat_model_name) create_model_response = sm_client.create_model( ModelName=chat_model_name, ExecutionRoleArn=role, PrimaryContainer={ "Image": chat_inference_image_uri, "ModelDataUrl": s3_code_artifact, },
)
chat_model_arn = create_model_response["ModelArn"] print(f"Created Model: {chat_model_arn}")

Configurer le point de terminaison

Ensuite, nous définissons les configurations de point de terminaison pour les modèles OpenChatKit. Nous déployons les modèles à l'aide du type d'instance ml.g5.12xlarge. Faire référence à create_endpoint_config pour plus de détails.

chat_endpoint_config_name = f"{chat_model_name}-config"
chat_endpoint_name = f"{chat_model_name}-endpoint" chat_endpoint_config_response = sm_client.create_endpoint_config( EndpointConfigName=chat_endpoint_config_name, ProductionVariants=[ { "VariantName": "variant1", "ModelName": chat_model_name, "InstanceType": "ml.g5.12xlarge", "InitialInstanceCount": 1, "ContainerStartupHealthCheckTimeoutInSeconds": 3600, }, ],
)

Déployer le point de terminaison

Enfin, nous créons un point de terminaison à l'aide du modèle et de la configuration du point de terminaison que nous avons définis dans les étapes précédentes :

chat_create_endpoint_response = sm_client.create_endpoint(
EndpointName=f"{chat_endpoint_name}", EndpointConfigName=chat_endpoint_config_name
)
print(f"Created Endpoint: {chat_create_endpoint_response['EndpointArn']},")

Exécuter l'inférence à partir des modèles OpenChatKit

Il est maintenant temps d'envoyer des requêtes d'inférence au modèle et d'obtenir les réponses. Nous passons l'invite de texte d'entrée et les paramètres de modèle tels que temperature, top_ket une max_new_tokens. La qualité des réponses du chatbot est basée sur les paramètres spécifiés, il est donc recommandé de comparer les performances du modèle à ces paramètres pour trouver le réglage optimal pour votre cas d'utilisation. L'invite d'entrée est d'abord envoyée au modèle de modération d'entrée, et la sortie est envoyée à ChatModel pour générer les réponses. Au cours de cette étape, le modèle utilise l'index Wikipedia pour récupérer les sections contextuellement pertinentes du modèle en tant qu'invite pour obtenir des réponses spécifiques au domaine du modèle. Enfin, la réponse du modèle est envoyée au modèle de modération de sortie pour vérifier la classification, puis les réponses sont renvoyées. Voir le code suivant :

def chat(prompt, session_id=None, **kwargs): if session_id: chat_response_model = smr_client.invoke_endpoint( EndpointName=chat_endpoint_name, Body=json.dumps( { "inputs": prompt, "parameters": { "temperature": 0.6, "top_k": 40, "max_new_tokens": 512, "session_id": session_id, "no_retrieval": True, }, } ), ContentType="application/json", ) else: chat_response_model = smr_client.invoke_endpoint( EndpointName=chat_endpoint_name, Body=json.dumps( { "inputs": prompt, "parameters": { "temperature": 0.6, "top_k": 40, "max_new_tokens": 512, }, } ), ContentType="application/json", ) response = chat_response_model["Body"].read().decode("utf8") return response
prompts = "What does a data engineer do?"
chat(prompts)

Reportez-vous aux exemples d'interactions de chat ci-dessous.

Nettoyer

Suivez les instructions de la section de nettoyage du pour supprimer les ressources provisionnées dans le cadre de cette publication afin d'éviter des frais inutiles. Faire référence à Tarification d'Amazon SageMaker pour plus de détails sur le coût des instances d'inférence.

Conclusion

Dans cet article, nous avons discuté de l'importance des LLM open source et de la manière de déployer un modèle OpenChatKit sur SageMaker pour créer des applications de chatbot de nouvelle génération. Nous avons discuté de divers composants des modèles OpenChatKit, des modèles de modération et de la manière d'utiliser une source de connaissances externe telle que Wikipedia pour les workflows de génération augmentée de récupération (RAG). Vous trouverez des instructions étape par étape dans le Bloc-notes GitHub. Faites-nous part des incroyables applications de chatbot que vous créez. Acclamations!

À propos des auteurs

Dhawal Patel est architecte principal en apprentissage machine chez AWS. Il a travaillé avec des organisations allant des grandes entreprises aux startups de taille moyenne sur des problèmes liés à l'informatique distribuée et à l'intelligence artificielle. Il se concentre sur l'apprentissage en profondeur, y compris les domaines de la PNL et de la vision par ordinateur. Il aide les clients à obtenir une inférence de modèle haute performance sur SageMaker.

Vikram Elango est un architecte de solutions spécialisé AIML senior chez AWS, basé en Virginie, aux États-Unis. Il se concentre actuellement sur l'IA générative, les LLM, l'ingénierie rapide, l'optimisation de l'inférence de grands modèles et la mise à l'échelle du ML dans les entreprises. Vikram aide les clients des secteurs de la finance et de l'assurance en matière de conception et de leadership éclairé pour créer et déployer des applications d'apprentissage automatique à grande échelle. Dans ses temps libres, il aime voyager, faire de la randonnée, cuisiner et camper avec sa famille.

Andrew Smith est ingénieur de support cloud au sein de l'équipe SageMaker, Vision & Other d'AWS, basée à Sydney, en Australie. Il assiste les clients utilisant de nombreux services AI/ML sur AWS avec une expertise dans le travail avec Amazon SageMaker. En dehors du travail, il aime passer du temps avec ses amis et sa famille ainsi qu'apprendre différentes technologies.

• Contenu propulsé par le référencement et distribution de relations publiques. Soyez amplifié aujourd'hui.
• Financement EVM. Interface unifiée pour la finance décentralisée. Accéder ici.
• Groupe de médias quantiques. IR/PR amplifié. Accéder ici.
• PlatoAiStream. Intelligence des données Web3. Connaissance Amplifiée. Accéder ici.
• La source: https://aws.amazon.com/blogs/machine-learning/build-custom-chatbot-applications-using-openchatkit-models-on-amazon-sagemaker/