Erstellen Sie benutzerdefinierte Chatbot-Anwendungen mit OpenChatkit-Modellen auf Amazon SageMaker | Amazon Web Services

Open-Source-Modelle für große Sprachen (LLMs) erfreuen sich zunehmender Beliebtheit und ermöglichen Forschern, Entwicklern und Organisationen den Zugriff auf diese Modelle, um Innovationen und Experimente zu fördern. Dies fördert die Zusammenarbeit der Open-Source-Community, um zur Entwicklung und Verbesserung von LLMs beizutragen. Open-Source-LLMs bieten Transparenz für die Modellarchitektur, den Trainingsprozess und die Trainingsdaten, sodass Forscher die Funktionsweise des Modells verstehen, potenzielle Vorurteile erkennen und ethische Bedenken ansprechen können. Diese Open-Source-LLMs demokratisieren die generative KI, indem sie fortschrittliche Technologie zur Verarbeitung natürlicher Sprache (NLP) einem breiten Spektrum von Benutzern zur Verfügung stellen, um geschäftskritische Geschäftsanwendungen zu erstellen. GPT-NeoX, LLaMA, Alpaca, GPT4All, Vicuna, Dolly und OpenAssistant sind einige der beliebtesten Open-Source-LLMs.

OpenChatKit ist ein Open-Source-LLM zum Erstellen allgemeiner und spezialisierter Chatbot-Anwendungen, das im März 2023 von Together Computer unter der Apache-2.0-Lizenz veröffentlicht wurde. Dieses Modell ermöglicht es Entwicklern, mehr Kontrolle über das Verhalten des Chatbots zu haben und es an ihre spezifischen Anwendungen anzupassen. OpenChatKit bietet eine Reihe von Tools, Basis-Bots und Bausteinen zum Erstellen vollständig angepasster, leistungsstarker Chatbots. Die Schlüsselkomponenten sind wie folgt:

• Ein auf Anweisungen abgestimmtes LLM, abgestimmt auf den Chat von EleutherAIs GPT-NeoX-20B mit über 43 Millionen Anweisungen auf 100 % COXNUMX-negativem Computing. Der GPT-NeoXT-Chat-Base-20B Das Modell basiert auf dem GPT-NeoX-Modell von EleutherAI und ist mit Daten abgestimmt, die sich auf Interaktionen im Dialogstil konzentrieren.
• Anpassungsrezepte zur Feinabstimmung des Modells, um eine hohe Genauigkeit bei Ihren Aufgaben zu erreichen.
• Ein erweiterbares Abrufsystem, mit dem Sie Bot-Antworten mit Informationen aus einem Dokumenten-Repository, einer API oder einer anderen live aktualisierten Informationsquelle zum Zeitpunkt der Inferenz ergänzen können.
• Ein Moderationsmodell, das anhand von GPT-JT-6B verfeinert wurde und dazu dient, zu filtern, auf welche Fragen der Bot antwortet.

Der zunehmende Umfang und die zunehmende Größe von Deep-Learning-Modellen stellen Hindernisse für den erfolgreichen Einsatz dieser Modelle in generativen KI-Anwendungen dar. Um den Anforderungen an geringe Latenz und hohen Durchsatz gerecht zu werden, ist der Einsatz anspruchsvoller Methoden wie Modellparallelität und Quantisierung unerlässlich. Mangels Kenntnissen in der Anwendung dieser Methoden haben zahlreiche Benutzer Schwierigkeiten, das Hosting umfangreicher Modelle für generative KI-Anwendungsfälle zu initiieren.

In diesem Beitrag zeigen wir, wie man OpenChatKit-Modelle bereitstellt (GPT-NeoXT-Chat-Base-20B and GPT-JT-Moderation-6B) Modelle auf Amazon Sage Maker unter Verwendung von DJL Serving und parallelen Open-Source-Modellbibliotheken wie DeepSpeed ​​und Hugging Face Accelerate. Wir verwenden DJL Serving, eine leistungsstarke, universelle Model-Serving-Lösung, die auf der Deep Java Library (DJL) basiert und unabhängig von der Programmiersprache ist. Wir zeigen, wie die Hugging Face Accelerate-Bibliothek die Bereitstellung großer Modelle auf mehreren GPUs vereinfacht und so den Aufwand für die verteilte Ausführung von LLMs verringert. Lass uns anfangen!

Erweiterbares Abrufsystem

Ein erweiterbares Abrufsystem ist eine der Schlüsselkomponenten von OpenChatKit. Es ermöglicht Ihnen, die Bot-Reaktion basierend auf einer geschlossenen Domänen-Wissensdatenbank anzupassen. Obwohl LLMs in der Lage sind, Faktenwissen in ihren Modellparametern beizubehalten und bei Feinabstimmung eine bemerkenswerte Leistung bei nachgelagerten NLP-Aufgaben zu erzielen, bleibt ihre Fähigkeit, auf geschlossenes Domänenwissen zuzugreifen und es genau vorherzusagen, begrenzt. Wenn ihnen daher wissensintensive Aufgaben gestellt werden, leidet ihre Leistung unter der von aufgabenspezifischen Architekturen. Sie können das OpenChatKit-Abrufsystem verwenden, um das Wissen in ihren Antworten aus externen Wissensquellen wie Wikipedia, Dokumentrepositorys, APIs und anderen Informationsquellen zu erweitern.

Das Retrieval-System ermöglicht es dem Chatbot, auf aktuelle Informationen zuzugreifen, indem es relevante Details als Antwort auf eine bestimmte Anfrage erhält, und stellt so den notwendigen Kontext bereit, damit das Modell Antworten generieren kann. Um die Funktionalität dieses Abrufsystems zu veranschaulichen, bieten wir Unterstützung für einen Index von Wikipedia-Artikeln und bieten Beispielcode an, der zeigt, wie eine Websuch-API für den Informationsabruf aufgerufen wird. Indem Sie die bereitgestellte Dokumentation befolgen, können Sie das Abrufsystem während des Inferenzprozesses in jeden Datensatz oder jede API integrieren, sodass der Chatbot dynamisch aktualisierte Daten in seine Antworten integrieren kann.

Moderationsmodell

Moderationsmodelle sind in Chatbot-Anwendungen wichtig, um Inhaltsfilterung, Qualitätskontrolle, Benutzersicherheit sowie rechtliche und Compliance-Gründe durchzusetzen. Moderation ist eine schwierige und subjektive Aufgabe und hängt stark von der Domäne der Chatbot-Anwendung ab. OpenChatKit bietet Tools zum Moderieren der Chatbot-Anwendung und zum Überwachen von Eingabeaufforderungen auf unangemessene Inhalte. Das Moderationsmodell bietet eine gute Basis, die an verschiedene Bedürfnisse angepasst und angepasst werden kann.

OpenChatKit verfügt über ein Moderationsmodell mit 6 Milliarden Parametern. GPT-JT-Moderation-6B, der den Chatbot moderieren kann, um die Eingaben auf die moderierten Themen zu beschränken. Obwohl das Modell selbst über eine gewisse Moderation verfügt, hat TogetherComputer a trainiert GPT-JT-Moderation-6B Modell mit Ontocord.ai's OIG-Moderationsdatensatz. Dieses Modell läuft neben dem Haupt-Chatbot, um zu überprüfen, dass sowohl die Benutzereingabe als auch die Antwort des Bots keine unangemessenen Ergebnisse enthalten. Sie können dies auch verwenden, um Fragen an den Chatbot zu erkennen, die außerhalb der Domäne liegen, und diese zu überschreiben, wenn die Frage nicht Teil der Domäne des Chatbots ist.

Das folgende Diagramm veranschaulicht den OpenChatKit-Workflow.

Anwendungsfälle für erweiterbare Abrufsysteme

Obwohl wir diese Technik in verschiedenen Branchen anwenden können, um generative KI-Anwendungen zu erstellen, diskutieren wir in diesem Beitrag Anwendungsfälle in der Finanzbranche. Retrieval Augmented Generation kann in der Finanzforschung eingesetzt werden, um automatisch Forschungsberichte zu bestimmten Unternehmen, Branchen oder Finanzprodukten zu erstellen. Durch den Abruf relevanter Informationen aus internen Wissensdatenbanken, Finanzarchiven, Nachrichtenartikeln und Forschungspapieren können Sie umfassende Berichte erstellen, die wichtige Erkenntnisse, Finanzkennzahlen, Markttrends und Anlageempfehlungen zusammenfassen. Mit dieser Lösung können Sie Finanznachrichten, Marktstimmung und Trends überwachen und analysieren.

Lösungsüberblick

Die folgenden Schritte sind erforderlich, um einen Chatbot mithilfe von OpenChatKit-Modellen zu erstellen und auf SageMaker bereitzustellen:

1. Laden Sie die Chat-Basis herunter GPT-NeoXT-Chat-Base-20B Modellieren und verpacken Sie die Modellartefakte, in die hochgeladen werden soll Amazon Simple Storage-Service (Amazon S3).
2. Verwenden Sie einen LMI-Container (Large Model Inference) von SageMaker, konfigurieren Sie die Eigenschaften und richten Sie benutzerdefinierten Inferenzcode ein, um dieses Modell bereitzustellen.
3. Konfigurieren Sie modellparallele Techniken und verwenden Sie Inferenzoptimierungsbibliotheken in DJL-Bereitstellungseigenschaften. Wir werden Hugging Face Accelerate als Engine für die DJL-Bereitstellung verwenden. Darüber hinaus definieren wir tensorparallele Konfigurationen, um das Modell zu partitionieren.
4. Erstellen Sie ein SageMaker-Modell und eine Endpunktkonfiguration und stellen Sie den SageMaker-Endpunkt bereit.

Sie können mitmachen, indem Sie das Notizbuch im ausführen GitHub Repo.

Laden Sie das OpenChatKit-Modell herunter

Zuerst laden wir das OpenChatKit-Basismodell herunter. Wir gebrauchen huggingface_hub Und verwenden snapshot_download um das Modell herunterzuladen, wodurch ein gesamtes Repository mit einer bestimmten Revision heruntergeladen wird. Um den Vorgang zu beschleunigen, werden gleichzeitig Downloads durchgeführt. Siehe den folgenden Code:

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.
)

DJL bedient Immobilien

Sie können SageMaker LMI-Container verwenden, um große generative KI-Modelle mit benutzerdefiniertem Inferenzcode zu hosten, ohne Ihren eigenen Inferenzcode bereitzustellen. Dies ist äußerst nützlich, wenn keine benutzerdefinierte Vorverarbeitung der Eingabedaten oder Nachverarbeitung der Modellvorhersagen erfolgt. Sie können ein Modell auch mithilfe von benutzerdefiniertem Inferenzcode bereitstellen. In diesem Beitrag zeigen wir, wie man OpenChatKit-Modelle mit benutzerdefiniertem Inferenzcode bereitstellt.

SageMaker erwartet die Modellartefakte im TAR-Format. Wir erstellen jedes OpenChatKit-Modell mit den folgenden Dateien: serving.properties und model.py.

Das serving.properties Die Konfigurationsdatei gibt DJL Serving an, welche Modellparallelisierungs- und Inferenzoptimierungsbibliotheken Sie verwenden möchten. Im Folgenden finden Sie eine Liste der Einstellungen, die wir in dieser Konfigurationsdatei verwenden:

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

Dieser enthält folgende Parameter:

• Sie – Die Engine, die DJL verwenden kann.
• option.entryPoint – Die Einstiegspunkt-Python-Datei oder das Python-Modul. Dies sollte mit dem verwendeten Motor übereinstimmen.
• option.s3url – Legen Sie dies auf den URI des S3-Buckets fest, der das Modell enthält.
• option.modelid – Wenn Sie das Modell von Huggingface.co herunterladen möchten, können Sie es festlegen option.modelid zur Modell-ID eines vorab trainierten Modells, das in einem Modell-Repository auf Huggingface.co gehostet wird (https://huggingface.co/models). Der Container verwendet diese Modell-ID, um das entsprechende Modell-Repository auf Huggingface.co herunterzuladen.
• option.tensor_parallel_degree – Legen Sie hier die Anzahl der GPU-Geräte fest, über die DeepSpeed ​​das Modell partitionieren muss. Dieser Parameter steuert auch die Anzahl der Worker pro Modell, die gestartet werden, wenn DJL Serving ausgeführt wird. Wenn wir beispielsweise über eine Maschine mit 8 GPUs verfügen und acht Partitionen erstellen, haben wir einen Worker pro Modell, der die Anforderungen bearbeitet. Es ist notwendig, den Grad der Parallelität zu optimieren und den optimalen Wert für eine bestimmte Modellarchitektur und Hardwareplattform zu ermitteln. Wir nennen das Fähigkeit inferenzadaptierter Parallelismus.

Beziehen auf Konfigurationen und Einstellungen für eine vollständige Liste der Optionen.

OpenChatKit-Modelle

Die OpenChatKit-Basismodellimplementierung verfügt über die folgenden vier Dateien:

• model.py – Diese Datei implementiert die Verarbeitungslogik für das Hauptmodell von OpenChatKit GPT-NeoX. Es empfängt die Inferenzeingabeanforderung, lädt das Modell, lädt den Wikipedia-Index und stellt die Antwort bereit. Beziehen auf model.py(erstellter Teil des Notizbuchs) für weitere Details. model.py verwendet die folgenden Schlüsselklassen:
  • OpenChatKitService – Dies übernimmt die Weitergabe der Daten zwischen dem GPT-NeoX-Modell, der Faiss-Suche und dem Konversationsobjekt. WikipediaIndex und Conversation Objekte werden initialisiert und Eingabe-Chat-Konversationen werden an den Index gesendet, um nach relevanten Inhalten aus Wikipedia zu suchen. Dadurch wird auch eine eindeutige ID für jeden Aufruf generiert, sofern diese nicht zum Zweck der Speicherung der Eingabeaufforderungen angegeben wird Amazon DynamoDB.
  • ChatModel – Diese Klasse lädt das Modell und den Tokenizer und generiert die Antwort. Es übernimmt die Partitionierung des Modells auf mehrere GPUs tensor_parallel_degree, und konfiguriert die dtypes und device_map. Die Eingabeaufforderungen werden an das Modell übergeben, um Antworten zu generieren. Ein Stoppkriterium StopWordsCriteria ist so konfiguriert, dass die Generierung nur die Bot-Antwort bei Inferenz erzeugt.
  • Moderationsmodell – Wir nutzen zwei Moderationsmodelle im ModerationModel Klasse: das Eingabemodell, um dem Chat-Modell anzuzeigen, dass die Eingabe ungeeignet ist, um das Inferenzergebnis zu überschreiben, und das Ausgabemodell, um das Inferenzergebnis zu überschreiben. Wir klassifizieren die Eingabeaufforderung und Ausgabeantwort mit den folgenden möglichen Bezeichnungen:
    • lässig
    • braucht Vorsicht
    • erfordert Intervention (dies wird vom Modell als moderiert gekennzeichnet)
    • Möglicherweise ist Vorsicht geboten
    • wahrscheinlich ist Vorsicht geboten
• wikipedia_prepare.py – Diese Datei übernimmt das Herunterladen und Vorbereiten des Wikipedia-Index. In diesem Beitrag verwenden wir einen Wikipedia-Index zu Hugging Face-Datensätzen. Um die Wikipedia-Dokumente nach relevantem Text zu durchsuchen, muss der Index von Hugging Face heruntergeladen werden, da er nicht anderswo verpackt ist. Der wikipedia_prepare.py Die Datei ist für die Handhabung des Downloads beim Import verantwortlich. Nur ein einzelner Prozess in den mehreren Prozessen, die zur Inferenz ausgeführt werden, kann das Repository klonen. Der Rest wartet, bis die Dateien im lokalen Dateisystem vorhanden sind.
• wikipedia.py – Diese Datei wird für die Suche im Wikipedia-Index nach kontextrelevanten Dokumenten verwendet. Die Eingabeabfrage wird tokenisiert und Einbettungen werden mit erstellt mean_pooling. Wir berechnen Cosinus-Ähnlichkeitsdistanzmetriken zwischen der Abfrageeinbettung und dem Wikipedia-Index, um kontextrelevante Wikipedia-Sätze abzurufen. Beziehen auf wikipedia.py für Ausführungsdetails.

#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)

• Konversation.py – Diese Datei wird zum Speichern und Abrufen des Konversationsthreads in DynamoDB zur Weitergabe an das Modell und den Benutzer verwendet. conversation.py ist aus dem Open-Source-Repository OpenChatKit übernommen. Diese Datei ist für die Definition des Objekts verantwortlich, das die Gesprächsrunden zwischen dem Menschen und dem Modell speichert. Dadurch ist das Modell in der Lage, eine Sitzung für die Konversation beizubehalten, sodass ein Benutzer auf frühere Nachrichten zurückgreifen kann. Da SageMaker-Endpunktaufrufe zustandslos sind, muss diese Konversation an einem Ort außerhalb der Endpunktinstanzen gespeichert werden. Beim Start erstellt die Instanz eine DynamoDB-Tabelle, falls diese nicht vorhanden ist. Alle Aktualisierungen der Konversation werden dann basierend auf dem in DynamoDB gespeichert session_id Schlüssel, der vom Endpunkt generiert wird. Jeder Aufruf mit einer Sitzungs-ID ruft die zugehörige Konversationszeichenfolge ab und aktualisiert sie nach Bedarf.

Erstellen Sie einen LMI-Inferenzcontainer mit benutzerdefinierten Abhängigkeiten

Die Indexsuche nutzt Facebooks Faiß Bibliothek zur Durchführung der Ähnlichkeitssuche. Da dies nicht im Basis-LMI-Image enthalten ist, muss der Container angepasst werden, um diese Bibliothek zu installieren. Der folgende Code definiert eine Docker-Datei, die Faiss von der Quelle zusammen mit anderen vom Bot-Endpunkt benötigten Bibliotheken installiert. Wir benutzen das sm-docker Dienstprogramm zum Erstellen und Übertragen des Images Amazon Elastic Container-Registrierung (Amazon ECR) von Amazon SageMaker-Studio. Beziehen auf Verwenden der Amazon SageMaker Studio Image CLI zum Erstellen von Container-Images aus Ihren Studio-Notebooks für weitere Informationen an.

Im DJL-Container ist Conda nicht installiert, daher muss Faiss geklont und aus der Quelle kompiliert werden. Um Faiss zu installieren, müssen die Abhängigkeiten für die Verwendung der BLAS-APIs und der Python-Unterstützung installiert werden. Nach der Installation dieser Pakete wird Faiss für die Verwendung von AVX2 und CUDA konfiguriert, bevor es mit den installierten Python-Erweiterungen kompiliert wird.

pandas, fastparquet, boto3 und git-lfs werden nachträglich installiert, da diese zum Herunterladen und Lesen der Indexdateien benötigt werden.

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

Modell erstellen

Da wir nun das Docker-Image in Amazon ECR haben, können wir mit der Erstellung des SageMaker-Modellobjekts für die OpenChatKit-Modelle fortfahren. Wir stellen bereit GPT-NeoXT-Chat-Base-20B Input- und Output-Moderationsmodelle unter Verwendung GPT-JT-Moderation-6B. Beziehen auf create_model für weitere Informationen an.

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}")

Konfigurieren Sie den Endpunkt

Als Nächstes definieren wir die Endpunktkonfigurationen für die OpenChatKit-Modelle. Wir stellen die Modelle mithilfe des Instanztyps ml.g5.12xlarge bereit. Beziehen auf create_endpoint_config für weitere Informationen an.

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, }, ],
)

Stellen Sie den Endpunkt bereit

Schließlich erstellen wir einen Endpunkt mithilfe des Modells und der Endpunktkonfiguration, die wir in den vorherigen Schritten definiert haben:

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']},")

Führen Sie Rückschlüsse aus OpenChatKit-Modellen aus

Jetzt ist es an der Zeit, Inferenzanfragen an das Modell zu senden und die Antworten zu erhalten. Wir übergeben den Eingabeaufforderungstext und Modellparameter wie z temperature, top_k und max_new_tokens. Die Qualität der Chatbot-Antworten basiert auf den angegebenen Parametern. Daher wird empfohlen, die Modellleistung anhand dieser Parameter zu vergleichen, um die optimale Einstellung für Ihren Anwendungsfall zu finden. Die Eingabeaufforderung wird zunächst an das Eingabemoderationsmodell gesendet, und die Ausgabe wird an gesendet ChatModel um die Antworten zu generieren. Während dieses Schritts verwendet das Modell den Wikipedia-Index, um kontextrelevante Abschnitte des Modells abzurufen, als Aufforderung, domänenspezifische Antworten vom Modell zu erhalten. Schließlich wird die Modellantwort an das Ausgabemoderationsmodell gesendet, um die Klassifizierung zu überprüfen, und dann werden die Antworten zurückgegeben. Siehe den folgenden Code:

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)

Nachfolgend finden Sie Beispiele für Chat-Interaktionen.

Aufräumen

Befolgen Sie die Anweisungen im Bereinigungsabschnitt des, um die im Rahmen dieses Beitrags bereitgestellten Ressourcen zu löschen und unnötige Kosten zu vermeiden. Beziehen auf Amazon SageMaker Preise Einzelheiten zu den Kosten der Inferenzinstanzen finden Sie hier.

Zusammenfassung

In diesem Beitrag haben wir die Bedeutung von Open-Source-LLMs und die Bereitstellung eines OpenChatKit-Modells auf SageMaker diskutiert, um Chatbot-Anwendungen der nächsten Generation zu erstellen. Wir diskutierten verschiedene Komponenten von OpenChatKit-Modellen, Moderationsmodellen und die Verwendung einer externen Wissensquelle wie Wikipedia für Retrieval Augmented Generation (RAG)-Workflows. Eine Schritt-für-Schritt-Anleitung finden Sie im GitHub-Notizbuch. Informieren Sie uns über die fantastischen Chatbot-Anwendungen, die Sie erstellen. Beifall!

Über die Autoren

Dhawal Patel ist Principal Machine Learning Architect bei AWS. Er hat mit Organisationen von großen Unternehmen bis hin zu mittelständischen Startups an Problemen im Zusammenhang mit verteiltem Computing und künstlicher Intelligenz gearbeitet. Er konzentriert sich auf Deep Learning, einschließlich NLP- und Computer Vision-Domänen. Er hilft Kunden, hochleistungsfähige Modellinferenz auf SageMaker zu erreichen.

Vikram Elango ist Senior AIML Specialist Solutions Architect bei AWS mit Sitz in Virginia, USA. Derzeit konzentriert er sich auf generative KI, LLMs, Prompt Engineering, Optimierung großer Modellinferenzen und unternehmensweite Skalierung von ML. Vikram unterstützt Kunden aus der Finanz- und Versicherungsbranche mit Design und Vordenkerrolle bei der Entwicklung und Bereitstellung von Anwendungen für maschinelles Lernen in großem Maßstab. In seiner Freizeit reist er gerne, wandert, kocht und campt mit seiner Familie.

Andrew Smith ist ein Cloud-Support-Ingenieur im SageMaker, Vision & Other-Team bei AWS mit Sitz in Sydney, Australien. Er unterstützt Kunden, die viele KI/ML-Dienste auf AWS nutzen, mit Fachwissen in der Arbeit mit Amazon SageMaker. Außerhalb der Arbeit verbringt er gerne Zeit mit Freunden und Familie und lernt verschiedene Technologien kennen.

• SEO-gestützte Content- und PR-Distribution. Holen Sie sich noch heute Verstärkung.
• EVM-Finanzen. Einheitliche Schnittstelle für dezentrale Finanzen. Hier zugreifen.
• Quantum Media Group. IR/PR verstärkt. Hier zugreifen.
• PlatoAiStream. Web3-Datenintelligenz. Wissen verstärkt. Hier zugreifen.
• Quelle: https://aws.amazon.com/blogs/machine-learning/build-custom-chatbot-applications-using-openchatkit-models-on-amazon-sagemaker/