Byg brugerdefinerede chatbot-applikationer ved hjælp af OpenChatkit-modeller på Amazon SageMaker | Amazon Web Services

Open source store sprogmodeller (LLM'er) er blevet populære, hvilket giver forskere, udviklere og organisationer adgang til disse modeller for at fremme innovation og eksperimenter. Dette tilskynder til samarbejde fra open source-fællesskabet for at bidrage til udvikling og forbedring af LLM'er. Open source LLM'er giver gennemsigtighed til modelarkitekturen, træningsprocessen og træningsdata, som giver forskere mulighed for at forstå, hvordan modellen fungerer og identificere potentielle skævheder og adressere etiske bekymringer. Disse open source LLM'er demokratiserer generativ kunstig intelligens ved at gøre avanceret NLP-teknologi (natural language processing) tilgængelig for en bred vifte af brugere til at bygge missionskritiske forretningsapplikationer. GPT-NeoX, LLaMA, Alpaca, GPT4All, Vicuna, Dolly og OpenAssistant er nogle af de populære open source LLM'er.

OpenChatKit er en open source LLM, der bruges til at bygge generelle og specialiserede chatbot-applikationer, udgivet af Together Computer i marts 2023 under Apache-2.0-licensen. Denne model giver udviklere mulighed for at have mere kontrol over chatbottens adfærd og skræddersy den til deres specifikke applikationer. OpenChatKit giver et sæt værktøjer, basisbot og byggeklodser til at bygge fuldt tilpassede, kraftfulde chatbots. Nøglekomponenterne er som følger:

• En instruktionstunet LLM, finjusteret til chat fra EleutherAIs GPT-NeoX-20B med over 43 millioner instruktioner på 100 % kulstofnegativ beregning. Det GPT-NeoXT-Chat-Base-20B modellen er baseret på EleutherAIs GPT-NeoX-model og er finjusteret med data, der fokuserer på dialog-stil interaktioner.
• Tilpasningsopskrifter til at finjustere modellen for at opnå høj nøjagtighed på dine opgaver.
• Et udvideligt hentningssystem, der gør det muligt for dig at udvide bot-svar med information fra et dokumentlager, API eller en anden live-opdateringsinformationskilde på inferenstidspunkt.
• En modereringsmodel, finjusteret fra GPT-JT-6B, designet til at filtrere, hvilke spørgsmål botten svarer på.

Den stigende skala og størrelse af deep learning-modeller udgør forhindringer for succesfuldt at implementere disse modeller i generative AI-applikationer. For at imødekomme kravene til lav latenstid og høj gennemløb bliver det vigtigt at anvende sofistikerede metoder som modelparallelisme og kvantisering. Mange brugere, der mangler færdigheder i anvendelsen af ​​disse metoder, støder på vanskeligheder med at starte hosting af store modeller til generative AI-brugssager.

I dette indlæg viser vi, hvordan man implementerer OpenChatKit-modeller (GPT-NeoXT-Chat-Base-20B and GPT-JT-Moderation-6B) modeller på Amazon SageMaker ved hjælp af DJL Serving og open source-model parallelbiblioteker som DeepSpeed ​​og Hugging Face Accelerate. Vi bruger DJL Serving, som er en højtydende universel modelserveringsløsning drevet af Deep Java Library (DJL), der er programmeringssprogsagnostisk. Vi demonstrerer, hvordan Hugging Face Accelerate-biblioteket forenkler implementeringen af ​​store modeller i flere GPU'er og derved reducerer byrden ved at køre LLM'er på en distribueret måde. Lad os komme igang!

Udvidbart afhentningssystem

Et udvideligt genfindingssystem er en af ​​nøglekomponenterne i OpenChatKit. Det giver dig mulighed for at tilpasse bot-svaret baseret på en videnbase for lukket domæne. Selvom LLM'er er i stand til at bevare faktuel viden i deres modelparametre og kan opnå bemærkelsesværdig ydeevne på downstream NLP-opgaver, når de er finjusteret, forbliver deres kapacitet til at få adgang til og forudsige lukket domæneviden nøjagtigt begrænset. Derfor, når de bliver præsenteret for videntunge opgaver, lider deres præstationer under opgavespecifikke arkitekturer. Du kan bruge OpenChatKit-hentningssystemet til at øge viden i deres svar fra eksterne videnkilder såsom Wikipedia, dokumentlagre, API'er og andre informationskilder.

Hentningssystemet gør det muligt for chatbotten at få adgang til aktuelle oplysninger ved at indhente relevante detaljer som svar på en specifik forespørgsel, og derved levere den nødvendige kontekst til, at modellen kan generere svar. For at illustrere funktionaliteten af ​​dette genfindingssystem yder vi support til et indeks over Wikipedia-artikler og tilbyder eksempelkode, der demonstrerer, hvordan man kalder en websøgnings-API til informationssøgning. Ved at følge den medfølgende dokumentation kan du integrere genfindingssystemet med ethvert datasæt eller API under inferensprocessen, hvilket giver chatbotten mulighed for at inkorporere dynamisk opdaterede data i sine svar.

Moderation model

Modereringsmodeller er vigtige i chatbot-applikationer for at håndhæve indholdsfiltrering, kvalitetskontrol, brugersikkerhed og juridiske og overholdelsesmæssige årsager. Moderering er en vanskelig og subjektiv opgave, og afhænger meget af chatbot-applikationens domæne. OpenChatKit giver værktøjer til at moderere chatbot-applikationen og overvåge inputtekstprompter for upassende indhold. Moderationsmodellen giver en god baseline, der kan tilpasses og tilpasses forskellige behov.

OpenChatKit har en modereringsmodel med 6 milliarder parametre, GPT-JT-Moderation-6B, som kan moderere chatbotten for at begrænse input til de modererede emner. Selvom selve modellen har en vis mådehold indbygget, trænede TogetherComputer en GPT-JT-Moderation-6B model med Ontocord.ai's OIG-moderation datasæt. Denne model kører sammen med hovedchatbotten for at kontrollere, at både brugerinput og svar fra botten ikke indeholder upassende resultater. Du kan også bruge dette til at registrere eventuelle spørgsmål uden for domænet til chatbotten og tilsidesætte, når spørgsmålet ikke er en del af chatbottens domæne.

Følgende diagram illustrerer OpenChatKit-arbejdsgangen.

Brugssager til udvidbart hentningssystem

Selvom vi kan anvende denne teknik i forskellige industrier til at bygge generative AI-applikationer, diskuterer vi til dette indlæg brugssager i den finansielle industri. Retrieval augmented generation kan anvendes i finansiel forskning til automatisk at generere forskningsrapporter om specifikke virksomheder, brancher eller finansielle produkter. Ved at hente relevant information fra interne vidensbaser, finansielle arkiver, nyhedsartikler og forskningsartikler kan du generere omfattende rapporter, der opsummerer nøgleindsigter, økonomiske målinger, markedstendenser og investeringsanbefalinger. Du kan bruge denne løsning til at overvåge og analysere finansielle nyheder, markedsstemning og tendenser.

Løsningsoversigt

Følgende trin er involveret for at bygge en chatbot ved hjælp af OpenChatKit-modeller og implementere dem på SageMaker:

1. Download chatbasen GPT-NeoXT-Chat-Base-20B model og pak de modelartefakter, der skal uploades til Amazon Simple Storage Service (Amazon S3).
2. Brug en SageMaker large model inference (LMI) container, konfigurer egenskaberne, og opsæt tilpasset inferenskode for at implementere denne model.
3. Konfigurer modelparallelle teknikker og brug inferensoptimeringsbiblioteker i DJL-serveringsegenskaber. Vi vil bruge Hugging Face Accelerate som motor til DJL-servering. Derudover definerer vi tensorparallelle konfigurationer for at opdele modellen.
4. Opret en SageMaker-model og -slutpunktskonfiguration, og implementer SageMaker-slutpunktet.

Du kan følge med ved at køre notesbogen i GitHub repo.

Download OpenChatKit-modellen

Først downloader vi OpenChatKit-basismodellen. Vi bruger huggingface_hub Og brug snapshot_download at downloade modellen, som downloader et helt lager ved en given revision. Downloads foretages samtidigt for at fremskynde processen. Se følgende kode:

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 Serveringsejendomme

Du kan bruge SageMaker LMI-beholdere til at være vært for store generative AI-modeller med tilpasset slutningskode uden at angive din egen slutningskode. Dette er yderst nyttigt, når der ikke er nogen tilpasset forbehandling af inputdata eller efterbehandling af modellens forudsigelser. Du kan også implementere en model ved hjælp af tilpasset slutningskode. I dette indlæg demonstrerer vi, hvordan man implementerer OpenChatKit-modeller med tilpasset inferenskode.

SageMaker forventer, at modellens artefakter er i tjæreformat. Vi opretter hver OpenChatKit-model med følgende filer: serving.properties , model.py.

serving.properties konfigurationsfilen angiver til DJL Serving, hvilke modelparalleliserings- og inferensoptimeringsbiblioteker du gerne vil bruge. Følgende er en liste over indstillinger, vi bruger i denne konfigurationsfil:

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

Dette indeholder følgende parametre:

• motor – Motoren til DJL at bruge.
• option.entryPoint – Indgangspunktet Python-fil eller -modul. Dette skal passe med den motor, der bruges.
• option.s3url – Indstil dette til URI'en for den S3-spand, der indeholder modellen.
• option.modelid – Hvis du vil downloade modellen fra huggingface.co, kan du indstille option.modelid til model-id'et for en forudtrænet model, der er hostet i et modellager på huggingface.co (https://huggingface.co/models). Containeren bruger dette model-id til at downloade det tilsvarende modellager på huggingface.co.
• option.tensor_parallel_degree – Indstil dette til antallet af GPU-enheder, som DeepSpeed ​​skal bruge for at partitionere modellen. Denne parameter styrer også antallet af arbejdere pr. model, der vil blive startet op, når DJL Serving kører. For eksempel, hvis vi har en 8 GPU-maskine, og vi opretter otte partitioner, vil vi have en arbejder pr. model til at betjene anmodningerne. Det er nødvendigt at justere parallelitetsgraden og identificere den optimale værdi for en given modelarkitektur og hardwareplatform. Det kalder vi evne slutningstilpasset parallelisme.

Der henvises til Konfigurationer og indstillinger for en udtømmende liste over muligheder.

OpenChatKit-modeller

OpenChatKit basismodelimplementeringen har følgende fire filer:

• model.py – Denne fil implementerer håndteringslogikken for hovedmodellen OpenChatKit GPT-NeoX. Den modtager anmodningen om inferensinput, indlæser modellen, indlæser Wikipedia-indekset og betjener svaret. Henvise til model.py(oprettet del af notesbogen) for yderligere detaljer. model.py bruger følgende nøgleklasser:
  • OpenChatKitService – Dette håndterer overførsel af data mellem GPT-NeoX-modellen, Faiss-søgning og samtaleobjekt. WikipediaIndex , Conversation objekter initialiseres, og inputchatsamtaler sendes til indekset for at søge efter relevant indhold fra Wikipedia. Dette genererer også et unikt ID for hver påkaldelse, hvis der ikke leveres et med det formål at gemme meddelelserne i Amazon DynamoDB.
  • Chatmodel – Denne klasse indlæser modellen og tokenizer og genererer svaret. Det håndterer opdeling af modellen på tværs af flere GPU'er ved hjælp af tensor_parallel_degree, og konfigurerer dtypes , device_map. Prompterne sendes til modellen for at generere svar. Et stopkriterie StopWordsCriteria er konfigureret til, at generationen kun producerer bot-svaret ved inferens.
  • Modereringsmodel – Vi bruger to moderationsmodeller i ModerationModel klasse: inputmodellen til at indikere over for chatmodellen, at inputtet er upassende til at tilsidesætte slutningsresultatet, og outputmodellen til at tilsidesætte slutningsresultatet. Vi klassificerer inputprompten og outputsvaret med følgende mulige etiketter:
    • afslappet
    • kræver forsigtighed
    • har brug for intervention (dette er markeret for at blive modereret af modellen)
    • kræver muligvis forsigtighed
    • kræver sandsynligvis forsigtighed
• wikipedia_prepare.py – Denne fil håndterer download og forberedelse af Wikipedia-indekset. I dette indlæg bruger vi et Wikipedia-indeks til rådighed på datasæt for Hugging Face. For at søge i Wikipedia-dokumenterne efter relevant tekst, skal indekset downloades fra Hugging Face, fordi det ikke er pakket andre steder. Det wikipedia_prepare.py filen er ansvarlig for at håndtere download, når den importeres. Kun en enkelt proces i multiplen, der kører for inferens, kan klone depotet. Resten venter, indtil filerne er til stede i det lokale filsystem.
• wikipedia.py – Denne fil bruges til at søge i Wikipedia-indekset efter kontekstuelt relevante dokumenter. Inputforespørgslen er tokeniseret, og indlejringer oprettes ved hjælp af mean_pooling. Vi beregner cosinus-lighedsafstandsmetrikker mellem forespørgselsindlejringen og Wikipedia-indekset for at hente kontekstuelt relevante Wikipedia-sætninger. Henvise til wikipedia.py for implementeringsdetaljer.

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

• samtale.py – Denne fil bruges til at gemme og hente samtaletråden i DynamoDB til videregivelse til modellen og brugeren. conversation.py er tilpasset fra open-source OpenChatKit-lageret. Denne fil er ansvarlig for at definere det objekt, der gemmer samtaledrejningerne mellem mennesket og modellen. Hermed er modellen i stand til at beholde en session for samtalen, så en bruger kan henvise til tidligere beskeder. Fordi SageMaker-endepunktkaldelser er statsløse, skal denne samtale gemmes et sted uden for slutpunktforekomsterne. Ved opstart opretter instansen en DynamoDB-tabel, hvis den ikke eksisterer. Alle opdateringer til samtalen gemmes derefter i DynamoDB baseret på session_id nøgle, som genereres af slutpunktet. Enhver påkaldelse med et sessions-id vil hente den tilknyttede samtalestreng og opdatere den efter behov.

Byg en LMI-inferenscontainer med tilpassede afhængigheder

Indekssøgningen bruger Facebooks Faiss bibliotek til at udføre lighedssøgningen. Fordi dette ikke er inkluderet i basis-LMI-billedet, skal containeren tilpasses for at installere dette bibliotek. Den følgende kode definerer en Dockerfile, der installerer Faiss fra kilden sammen med andre biblioteker, der er nødvendige for bot-slutpunktet. Vi bruger sm-docker værktøj til at bygge og skubbe billedet til Amazon Elastic Container Registry (Amazon ECR) fra Amazon SageMaker Studio. Henvise til Brug af Amazon SageMaker Studio Image Build CLI til at bygge containerbilleder fra dine Studio-notesbøger for flere detaljer.

DJL-containeren har ikke Conda installeret, så Faiss skal klones og kompileres fra kilden. For at installere Faiss skal afhængighederne til brug af BLAS API'er og Python-understøttelse være installeret. Efter at disse pakker er installeret, er Faiss konfigureret til at bruge AVX2 og CUDA, før den kompileres med Python-udvidelserne installeret.

pandas, fastparquet, boto3og git-lfs installeres efterfølgende, fordi disse er nødvendige for at downloade og læse indeksfilerne.

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

Opret modellen

Nu hvor vi har Docker-billedet i Amazon ECR, kan vi fortsætte med at oprette SageMaker-modelobjektet til OpenChatKit-modellerne. Vi sætter ind GPT-NeoXT-Chat-Base-20B input og output moderering modeller ved hjælp af GPT-JT-Moderation-6B. Henvise til skabe_model for flere 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}")

Konfigurer slutpunktet

Dernæst definerer vi slutpunktskonfigurationerne for OpenChatKit-modellerne. Vi implementerer modellerne ved hjælp af instanstypen ml.g5.12xlarge. Henvise til create_endpoint_config for flere 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, }, ],
)

Implementer slutpunktet

Til sidst opretter vi et endepunkt ved hjælp af den model og endepunktskonfiguration, vi definerede i de foregående trin:

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 inferens fra OpenChatKit-modeller

Nu er det tid til at sende slutningsanmodninger til modellen og få svarene. Vi sender inputtekstprompten og modelparametre som f.eks temperature, top_kog max_new_tokens. Kvaliteten af ​​chatbot-svarene er baseret på de angivne parametre, så det anbefales at benchmarke modellens ydeevne i forhold til disse parametre for at finde den optimale indstilling til din brug. Input-prompten sendes først til inputmodereringsmodellen, og outputtet sendes til ChatModel at generere svarene. Under dette trin bruger modellen Wikipedia-indekset til at hente kontekstuelt relevante sektioner til modellen som en prompt for at få domænespecifikke svar fra modellen. Til sidst sendes modelsvaret til outputmodereringsmodellen for at tjekke for klassificering, og derefter returneres svarene. Se følgende kode:

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 eksempler på chatinteraktioner nedenfor.

Ryd op

Følg instruktionerne i oprydningssektionen for at slette de ressourcer, der er leveret som en del af dette indlæg for at undgå unødvendige gebyrer. Henvise til Amazon SageMaker-priser for detaljer om omkostningerne ved slutningstilfældene.

Konklusion

I dette indlæg diskuterede vi vigtigheden af ​​open source LLM'er og hvordan man implementerer en OpenChatKit-model på SageMaker for at bygge næste generations chatbot-applikationer. Vi diskuterede forskellige komponenter i OpenChatKit-modeller, modereringsmodeller og hvordan man bruger en ekstern videnkilde som Wikipedia til retrieval augmented generation (RAG) arbejdsgange. Du kan finde trin-for-trin instruktioner i GitHub notesbog. Fortæl os om de fantastiske chatbot-applikationer, du bygger. Skål!

Om forfatterne

Dhawal Patel er Principal Machine Learning Architect hos AWS. Han har arbejdet med organisationer lige fra store virksomheder til mellemstore startups om problemer relateret til distribueret computing og kunstig intelligens. Han fokuserer på Deep learning, herunder NLP og Computer Vision domæner. Han hjælper kunder med at opnå højtydende modelslutning på SageMaker.

Vikram Elango er Sr. AIML Specialist Solutions Architect hos AWS, baseret i Virginia, USA. Han er i øjeblikket fokuseret på generativ AI, LLM'er, prompt engineering, optimering af store modelslutninger og skalering af ML på tværs af virksomheder. Vikram hjælper finans- og forsikringsbranchens kunder med design og tankelederskab med at bygge og implementere maskinlæringsapplikationer i stor skala. I sin fritid nyder han at rejse, vandre, lave mad og campere med sin familie.

Andrew Smith er en Cloud Support Engineer i SageMaker, Vision & Other-teamet hos AWS, baseret i Sydney, Australien. Han støtter kunder, der bruger mange AI/ML-tjenester på AWS med ekspertise i at arbejde med Amazon SageMaker. Uden for arbejdet nyder han at bruge tid sammen med venner og familie samt lære om forskellige teknologier.

• SEO Powered Content & PR Distribution. Bliv forstærket i dag.
• EVM Finans. Unified Interface for Decentralized Finance. Adgang her.
• Quantum Media Group. IR/PR forstærket. Adgang her.
• PlatoAiStream. Web3 Data Intelligence. Viden forstærket. Adgang her.
• Kilde: https://aws.amazon.com/blogs/machine-learning/build-custom-chatbot-applications-using-openchatkit-models-on-amazon-sagemaker/