Bygg anpassade chatbot-applikationer med OpenChatkit-modeller på Amazon SageMaker | Amazon webbtjänster

Stora språkmodeller med öppen källkod (LLM) har blivit populära, vilket ger forskare, utvecklare och organisationer tillgång till dessa modeller för att främja innovation och experiment. Detta uppmuntrar samarbete från öppen källkodsgemenskapen för att bidra till utveckling och förbättring av LLM. LLM med öppen källkod ger insyn i modellarkitekturen, utbildningsprocessen och utbildningsdata, vilket gör att forskare kan förstå hur modellen fungerar och identifiera potentiella fördomar och ta itu med etiska problem. Dessa LLM:er med öppen källkod demokratiserar generativ AI genom att göra avancerad NLP-teknik (natural language processing) tillgänglig för ett brett spektrum av användare för att bygga verksamhetskritiska affärsapplikationer. GPT-NeoX, LLaMA, Alpaca, GPT4All, Vicuna, Dolly och OpenAssistant är några av de populära LLM:erna med öppen källkod.

OpenChatKit är en öppen källkod LLM som används för att bygga generella och specialiserade chatbot-applikationer, släppt av Together Computer i mars 2023 under Apache-2.0-licensen. Denna modell tillåter utvecklare att ha mer kontroll över chatbotens beteende och skräddarsy den till sina specifika applikationer. OpenChatKit tillhandahåller en uppsättning verktyg, basbot och byggstenar för att bygga helt anpassade, kraftfulla chatbotar. De viktigaste komponenterna är följande:

• En instruktionsjusterad LLM, finjusterad för chatt från EleutherAI:s GPT-NeoX-20B med över 43 miljoner instruktioner om 100 % kolnegativ beräkning. De GPT-NeoXT-Chat-Base-20B Modellen är baserad på EleutherAI:s GPT-NeoX-modell och är finjusterad med data som fokuserar på dialogliknande interaktioner.
• Anpassningsrecept för att finjustera modellen för att uppnå hög noggrannhet på dina uppgifter.
• Ett utbyggbart hämtningssystem som gör det möjligt för dig att utöka botsvar med information från ett dokumentförråd, API eller annan informationskälla som uppdateras live vid slutledningstidpunkten.
• En modereringsmodell, finjusterad från GPT-JT-6B, designad för att filtrera vilka frågor boten svarar på.

Den ökande omfattningen och storleken på modeller för djupinlärning utgör hinder för att framgångsrikt implementera dessa modeller i generativa AI-applikationer. För att möta kraven på låg latens och hög genomströmning blir det viktigt att använda sofistikerade metoder som modellparallellism och kvantisering. Eftersom de saknar kompetens i tillämpningen av dessa metoder, stöter många användare på svårigheter med att initiera värdskapet för stora modeller för generativa AI-användningsfall.

I det här inlägget visar vi hur man distribuerar OpenChatKit-modeller (GPT-NeoXT-Chat-Base-20B and GPT-JT-Moderation-6B) modeller på Amazon SageMaker använder DJL Serving och parallella bibliotek med öppen källkod som DeepSpeed ​​och Hugging Face Accelerate. Vi använder DJL Serving, som är en högpresterande universell modellserveringslösning som drivs av Deep Java Library (DJL) som är agnostisk för programmeringsspråk. Vi visar hur Hugging Face Accelerate-biblioteket förenklar distributionen av stora modeller i flera GPU:er och därigenom minskar bördan av att köra LLM:er på ett distribuerat sätt. Låt oss börja!

Utdragbart hämtningssystem

Ett utdragbart hämtningssystem är en av nyckelkomponenterna i OpenChatKit. Det gör att du kan anpassa botsvaret baserat på en kunskapsbas för sluten domän. Även om LLM:er kan behålla faktakunskaper i sina modellparametrar och kan uppnå enastående prestanda på nedströms NLP-uppgifter när de är finjusterade, förblir deras kapacitet att komma åt och förutsäga sluten domänkunskap exakt begränsad. Därför, när de presenteras för kunskapsintensiva uppgifter, blir deras prestanda mindre än uppgiftsspecifika arkitekturer. Du kan använda OpenChatKit-hämtningssystemet för att utöka kunskapen i deras svar från externa kunskapskällor som Wikipedia, dokumentförråd, API:er och andra informationskällor.

Hämtningssystemet gör det möjligt för chatboten att komma åt aktuell information genom att erhålla relevanta detaljer som svar på en specifik fråga, och därigenom tillhandahålla det nödvändiga sammanhanget för modellen att generera svar. För att illustrera funktionaliteten hos detta hämtningssystem tillhandahåller vi stöd för ett index över Wikipedia-artiklar och erbjuder exempelkod som visar hur man anropar ett webbsöknings-API för informationshämtning. Genom att följa den medföljande dokumentationen kan du integrera hämtningssystemet med valfri datauppsättning eller API under slutledningsprocessen, vilket gör att chatboten kan inkorporera dynamiskt uppdaterad data i sina svar.

Modereringsmodell

Modereringsmodeller är viktiga i chatbot-applikationer för att upprätthålla innehållsfiltrering, kvalitetskontroll, användarsäkerhet och juridiska och efterlevnadsskäl. Moderering är en svår och subjektiv uppgift, och beror mycket på domänen för chatbotapplikationen. OpenChatKit tillhandahåller verktyg för att moderera chatbot-applikationen och övervaka inmatningstextmeddelanden för olämpligt innehåll. Modereringsmodellen ger en bra baslinje som kan anpassas och anpassas efter olika behov.

OpenChatKit har en modereringsmodell med 6 miljarder parametrar, GPT-JT-Moderation-6B, som kan moderera chatboten för att begränsa ingångarna till de modererade ämnena. Även om själva modellen har viss moderering inbyggd, tränade TogetherComputer en GPT-JT-Moderation-6B modell med Ontocord.ai's OIG-moderering dataset. Den här modellen körs tillsammans med huvudchattboten för att kontrollera att både användarinmatningen och svaret från boten inte innehåller olämpliga resultat. Du kan också använda detta för att upptäcka eventuella frågor utanför domänen till chatboten och åsidosätta när frågan inte är en del av chatbotens domän.

Följande diagram illustrerar OpenChatKit-arbetsflödet.

Användningsfall för utökningsbara hämtningssystem

Även om vi kan tillämpa den här tekniken i olika branscher för att bygga generativa AI-applikationer, diskuterar vi för detta inlägg användningsfall inom finansbranschen. Retrieval augmented generation kan användas i finansiell forskning för att automatiskt generera forskningsrapporter om specifika företag, branscher eller finansiella produkter. Genom att hämta relevant information från interna kunskapsbaser, finansiella arkiv, nyhetsartiklar och forskningsrapporter kan du generera omfattande rapporter som sammanfattar viktiga insikter, finansiella mått, marknadstrender och investeringsrekommendationer. Du kan använda den här lösningen för att övervaka och analysera finansiella nyheter, marknadssentiment och trender.

Lösningsöversikt

Följande steg är involverade för att bygga en chatbot med OpenChatKit-modeller och distribuera dem på SageMaker:

1. Ladda ner chattbasen GPT-NeoXT-Chat-Base-20B modellera och paketera modellartefakterna som ska laddas upp till Amazon enkel lagringstjänst (Amazon S3).
2. Använd en SageMaker-behållare för stor modellinferens (LMI), konfigurera egenskaperna och ställ in anpassad slutledningskod för att distribuera den här modellen.
3. Konfigurera modellparallella tekniker och använd inferensoptimeringsbibliotek i DJL-serveregenskaper. Vi kommer att använda Hugging Face Accelerate som motor för DJL-servering. Dessutom definierar vi tensorparallella konfigurationer för att partitionera modellen.
4. Skapa en SageMaker-modell och slutpunktskonfiguration och distribuera SageMaker-slutpunkten.

Du kan följa med genom att köra anteckningsboken i GitHub repo.

Ladda ner OpenChatKit-modellen

Först laddar vi ner OpenChatKit-basmodellen. Vi använder huggingface_hub Och använda snapshot_download för att ladda ner modellen, som laddar ner ett helt arkiv vid en given version. Nedladdningar görs samtidigt för att påskynda processen. Se följande kod:

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 Serveringsfastigheter

Du kan använda SageMaker LMI-behållare för att vara värd för stora generativa AI-modeller med anpassad slutledningskod utan att ange din egen slutledningskod. Detta är extremt användbart när det inte finns någon anpassad förbearbetning av indata eller efterbearbetning av modellens förutsägelser. Du kan också distribuera en modell med hjälp av anpassad slutledningskod. I det här inlägget visar vi hur man distribuerar OpenChatKit-modeller med anpassad slutledningskod.

SageMaker förväntar sig modellartefakterna i tjärformat. Vi skapar varje OpenChatKit-modell med följande filer: serving.properties och model.py.

Smakämnen serving.properties konfigurationsfilen indikerar för DJL Serving vilka modellbibliotek för parallellisering och slutledningsoptimering du vill använda. Följande är en lista över inställningar som vi använder i den här konfigurationsfilen:

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

Detta innehåller följande parametrar:

• motor – Motorn för DJL att använda.
• option.entryPoint – Ingångspunkten Python-fil eller modul. Detta bör vara i linje med motorn som används.
• option.s3url – Ställ in detta på URI:n för S3-skopan som innehåller modellen.
• option.modelid – Om du vill ladda ner modellen från huggingface.co kan du ställa in option.modelid till modell-ID:t för en förtränad modell som finns i ett modellförråd på huggingface.co (https://huggingface.co/models). Behållaren använder detta modell-ID för att ladda ner motsvarande modelllager på huggingface.co.
• option.tensor_parallel_degree – Ställ in detta på antalet GPU-enheter som DeepSpeed ​​behöver för att partitionera modellen. Den här parametern styr också antalet arbetare per modell som kommer att startas upp när DJL Serving körs. Till exempel, om vi har en 8 GPU-maskin och vi skapar åtta partitioner, kommer vi att ha en arbetare per modell för att betjäna förfrågningarna. Det är nödvändigt att ställa in parallellitetsgraden och identifiera det optimala värdet för en given modellarkitektur och hårdvaruplattform. Vi kallar denna förmåga slutledningsanpassad parallellism.

Hänvisa till Konfigurationer och inställningar för en uttömmande lista över alternativ.

OpenChatKit-modeller

Implementeringen av OpenChatKit-basmodellen har följande fyra filer:

• modell.py – Den här filen implementerar hanteringslogiken för huvudmodellen OpenChatKit GPT-NeoX. Den tar emot begäran om slutledningsinmatning, laddar modellen, laddar Wikipedia-indexet och betjänar svaret. Hänvisa till model.py(skapad del av anteckningsboken) för ytterligare information. model.py använder följande nyckelklasser:
  • OpenChatKitService – Detta hanterar överföring av data mellan GPT-NeoX-modellen, Faiss-sökning och konversationsobjekt. WikipediaIndex och Conversation objekt initieras och ingående chattkonversationer skickas till indexet för att söka efter relevant innehåll från Wikipedia. Detta genererar också ett unikt ID för varje anrop om ett sådant inte tillhandahålls för att lagra uppmaningarna i Amazon DynamoDB.
  • Chattmodell – Den här klassen laddar modellen och tokenizern och genererar svaret. Den hanterar partitionering av modellen över flera GPU:er med hjälp av tensor_parallel_degreeoch konfigurerar dtypes och device_map. Uppmaningarna skickas till modellen för att generera svar. Ett stoppkriterie StopWordsCriteria är konfigurerad för att genereringen endast producerar bot-svaret vid slutledning.
  • Modereringsmodell – Vi använder två modereringsmodeller i ModerationModel klass: ingångsmodellen för att indikera för chattmodellen att inmatningen är olämplig för att åsidosätta slutledningsresultatet, och utdatamodellen för att åsidosätta slutledningsresultatet. Vi klassificerar ingångsmeddelandet och utmatningssvaret med följande möjliga etiketter:
    • avslappnad
    • behöver försiktighet
    • behöver ingripande (detta flaggas för att modereras av modellen)
    • behöver möjligen vara försiktig
    • behöver förmodligen försiktighet
• wikipedia_prepare.py – Den här filen hanterar nedladdning och förberedelse av Wikipedia-index. I det här inlägget använder vi ett Wikipedia-index som tillhandahålls på datauppsättningar för Hugging Face. För att söka i Wikipedia-dokumenten efter relevant text måste indexet laddas ner från Hugging Face eftersom det inte är förpackat någon annanstans. De wikipedia_prepare.py filen ansvarar för att hantera nedladdningen när den importeras. Endast en enda process i multipeln som körs för slutledning kan klona förvaret. Resten väntar tills filerna finns i det lokala filsystemet.
• wikipedia.py – Den här filen används för att söka i Wikipedias index efter kontextuellt relevanta dokument. Inmatningsfrågan tokeniseras och inbäddningar skapas med hjälp av mean_pooling. Vi beräknar cosinuslikhetsavståndsmått mellan inbäddningen av frågan och Wikipedia-indexet för att hämta kontextuellt relevanta Wikipedia-meningar. Hänvisa till wikipedia.py för genomförandedetaljer.

#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 – Den här filen används för att lagra och hämta konversationstråden i DynamoDB för vidarebefordran till modellen och användaren. conversation.py är anpassad från OpenChatKit-förrådet med öppen källkod. Den här filen är ansvarig för att definiera objektet som lagrar konversationssvängarna mellan människan och modellen. Med detta kan modellen behålla en session för konversationen, vilket gör att en användare kan referera till tidigare meddelanden. Eftersom SageMaker-ändpunktsanrop är tillståndslösa måste denna konversation lagras på en plats utanför slutpunktsinstanserna. Vid start skapar instansen en DynamoDB-tabell om den inte finns. Alla uppdateringar av konversationen lagras sedan i DynamoDB baserat på session_id nyckel, som genereras av slutpunkten. Varje anrop med ett sessions-ID hämtar den associerade konversationssträngen och uppdaterar den vid behov.

Bygg en LMI-inferensbehållare med anpassade beroenden

Indexsökningen använder Facebooks Faiss bibliotek för att utföra likhetssökningen. Eftersom detta inte ingår i bas-LMI-avbildningen måste behållaren anpassas för att installera det här biblioteket. Följande kod definierar en Dockerfil som installerar Faiss från källan tillsammans med andra bibliotek som behövs av botens slutpunkt. Vi använder sm-docker verktyg för att bygga och driva bilden till Amazon Elastic Container Registry (Amazon ECR) från Amazon SageMaker Studio. Hänvisa till Använda Amazon SageMaker Studio Image Build CLI för att bygga containerbilder från dina Studio-anteckningsböcker för mer detaljer.

DJL-behållaren har inte Conda installerat, så Faiss måste klonas och kompileras från källan. För att installera Faiss måste beroenden för att använda BLAS API:er och Python-stödet installeras. Efter att dessa paket har installerats konfigureras Faiss att använda AVX2 och CUDA innan de kompileras med Python-tilläggen installerade.

pandas, fastparquet, boto3och git-lfs installeras i efterhand eftersom dessa krävs för att ladda ner och läsa indexfilerna.

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

Skapa modellen

Nu när vi har Docker-bilden i Amazon ECR kan vi fortsätta med att skapa SageMaker-modellobjektet för OpenChatKit-modellerna. Vi sätter in GPT-NeoXT-Chat-Base-20B in- och utmatningsmodeller med hjälp av GPT-JT-Moderation-6B. Hänvisa till skapa_modell för mer detaljer.

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

Konfigurera slutpunkten

Därefter definierar vi slutpunktskonfigurationerna för OpenChatKit-modellerna. Vi distribuerar modellerna med hjälp av instanstypen ml.g5.12xlarge. Hänvisa till create_endpoint_config för mer detaljer.

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

Distribuera slutpunkten

Slutligen skapar vi en slutpunkt med den modell och slutpunktskonfiguration vi definierade i de föregående stegen:

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

Kör slutledning från OpenChatKit-modeller

Nu är det dags att skicka inferensförfrågningar till modellen och få svaren. Vi skickar inmatningstextprompten och modellparametrar som t.ex temperature, top_koch max_new_tokens. Kvaliteten på chatbotsvaren baseras på de angivna parametrarna, så det rekommenderas att jämföra modellprestanda mot dessa parametrar för att hitta den optimala inställningen för ditt användningsfall. Inmatningsprompten skickas först till ingångsmodereringsmodellen och utdata skickas till ChatModel för att generera svaren. Under det här steget använder modellen Wikipedia-indexet för att hämta kontextuellt relevanta avsnitt till modellen som en uppmaning för att få domänspecifika svar från modellen. Slutligen skickas modellsvaret till utdatamodereringsmodellen för att kontrollera klassificering, och sedan returneras svaren. Se följande kod:

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)

Se exempel på chattinteraktioner nedan.

Städa upp

Följ instruktionerna i rensningsavsnittet för att ta bort resurserna som tillhandahålls som en del av det här inlägget för att undvika onödiga avgifter. Hänvisa till Amazon SageMaker Prissättning för detaljer om kostnaden för slutledningsinstanserna.

Slutsats

I det här inlägget diskuterade vi vikten av LLM:er med öppen källkod och hur man distribuerar en OpenChatKit-modell på SageMaker för att bygga nästa generations chatbot-applikationer. Vi diskuterade olika komponenter i OpenChatKit-modeller, modereringsmodeller och hur man använder en extern kunskapskälla som Wikipedia för RAG-arbetsflöden (Retrieval Augmented Generation). Du hittar steg-för-steg-instruktioner i GitHub anteckningsbok. Berätta för oss om de fantastiska chatbot-applikationer du bygger. Skål!

Om författarna

Dhawal Patel är en huvudarkitekt för maskininlärning på AWS. Han har arbetat med organisationer som sträcker sig från stora företag till medelstora startups med problem relaterade till distribuerad datoranvändning och artificiell intelligens. Han fokuserar på djupinlärning inklusive NLP- och Computer Vision-domäner. Han hjälper kunder att uppnå högpresterande modellslutningar på SageMaker.

Vikram Elango är Sr. AIML Specialist Solutions Architect vid AWS, baserad i Virginia, USA. Han är för närvarande fokuserad på generativ AI, LLM, prompt ingenjörskonst, optimering av stora modellinferenser och skalning av ML mellan företag. Vikram hjälper finans- och försäkringsbranschens kunder med design och tankeledarskap att bygga och distribuera maskininlärningsapplikationer i stor skala. På fritiden tycker han om att resa, vandra, laga mat och campa med sin familj.

Andrew Smith är en Cloud Support Engineer i SageMaker, Vision & Other-teamet på AWS, baserat i Sydney, Australien. Han stödjer kunder som använder många AI/ML-tjänster på AWS med expertis i att arbeta med Amazon SageMaker. Utanför jobbet tycker han om att umgås med vänner och familj samt att lära sig om olika tekniker.

• SEO-drivet innehåll och PR-distribution. Bli förstärkt idag.
• EVM Finans. Unified Interface for Decentralized Finance. Tillgång här.
• Quantum Media Group. IR/PR förstärkt. Tillgång här.
• PlatoAiStream. Web3 Data Intelligence. Kunskap förstärkt. Tillgång här.
• Källa: https://aws.amazon.com/blogs/machine-learning/build-custom-chatbot-applications-using-openchatkit-models-on-amazon-sagemaker/