Byg en kontekstuel chatbot til finansielle tjenester ved hjælp af Amazon SageMaker JumpStart, Llama 2 og Amazon OpenSearch Serverless med Vector Engine | Amazon Web Services

Industrien for finansielle tjenesteydelser (FinServ) har unikke generative AI-krav relateret til domænespecifikke data, datasikkerhed, regulatoriske kontroller og branchestandarder. Derudover leder kunderne efter valg til at vælge den mest effektive og omkostningseffektive maskinlæringsmodel (ML) og evnen til at udføre den nødvendige tilpasning (finjustering) for at passe til deres forretningsbrug. Amazon SageMaker JumpStart er ideelt egnet til generative AI-brugssager for FinServ-kunder, fordi det giver de nødvendige datasikkerhedskontroller og opfylder kravene til overholdelse af standarder.

I dette indlæg demonstrerer vi spørgsmålsbesvarende opgaver ved hjælp af en Retrieval Augmented Generation (RAG)-baseret tilgang med store sprogmodeller (LLM'er) i SageMaker JumpStart ved hjælp af et simpelt økonomisk domænebrug. RAG er en ramme til at forbedre kvaliteten af ​​tekstgenerering ved at kombinere en LLM med et informationssøgningssystem (IR). Den LLM-genererede tekst, og IR-systemet henter relevant information fra en videnbase. Den hentede information bruges derefter til at øge LLM's input, hvilket kan hjælpe med at forbedre nøjagtigheden og relevansen af ​​den modelgenererede tekst. RAG har vist sig at være effektiv til en række forskellige tekstgenereringsopgaver, såsom besvarelse af spørgsmål og opsummering. Det er en lovende tilgang til at forbedre kvaliteten og nøjagtigheden af ​​tekstgenereringsmodeller.

Fordele ved at bruge SageMaker JumpStart

Med SageMaker JumpStart kan ML-udøvere vælge mellem et bredt udvalg af avancerede modeller til brugssager såsom indholdsskrivning, billedgenerering, kodegenerering, besvarelse af spørgsmål, copywriting, opsummering, klassificering, informationssøgning og mere. ML praktikere kan implementere fundamentmodeller til dedikerede Amazon SageMaker forekomster fra et netværksisoleret miljø og tilpasse modeller ved hjælp af SageMaker til modeltræning og implementering.

SageMaker JumpStart er ideelt egnet til generative AI-brugstilfælde for FinServ-kunder, fordi det tilbyder følgende:

• Tilpasningsmuligheder – SageMaker JumpStart giver eksempler på notesbøger og detaljerede indlæg til trin-for-trin vejledning om domænetilpasning af fundamentmodeller. Du kan følge disse ressourcer til finjustering, domænetilpasning og instruktion af fundamentmodeller eller til at bygge RAG-baserede applikationer.
• Datasikkerhed – Det er altafgørende at sikre sikkerheden af ​​inferensnyttelastdata. Med SageMaker JumpStart kan du implementere modeller i netværksisolation med enkelt-lejemåls-endepunkt. Desuden kan du administrere adgangskontrol til udvalgte modeller gennem den private model hub-funktion, tilpasset individuelle sikkerhedskrav.
• Reguleringskontrol og overholdelse – Overholdelse af standarder som HIPAA BAA, SOC123, PCI og HITRUST CSF er en kernefunktion i SageMaker, der sikrer tilpasning til finanssektorens strenge reguleringslandskab.
• Modelvalg – SageMaker JumpStart tilbyder et udvalg af state-of-the-art ML-modeller, der konsekvent rangerer blandt de bedste i branchens anerkendte HELM-benchmarks. Disse omfatter, men er ikke begrænset til, modellerne Llama 2, Falcon 40B, AI21 J2 Ultra, AI21 Summarize, Hugging Face MiniLM og BGE.

I dette indlæg udforsker vi opbygningen af ​​en kontekstuel chatbot til finansielle serviceorganisationer ved hjælp af en RAG-arkitektur med Llama 2-grundmodellen og Kramende ansigt GPTJ-6B-FP16 indlejringsmodel, begge tilgængelige i SageMaker JumpStart. Vi bruger også Vektor motor forum Amazon OpenSearch Serverløs (i øjeblikket i preview) som vektordatalageret til at gemme indlejringer.

Begrænsninger af store sprogmodeller

LLM'er er blevet trænet i store mængder ustrukturerede data og udmærker sig i generel tekstgenerering. Gennem denne uddannelse erhverver og opbevarer LLM'er faktuel viden. Imidlertid har hyldevare LLM'er begrænsninger:

• Deres offline træning gør dem uvidende om opdaterede oplysninger.
• Deres træning i overvejende generaliserede data mindsker deres effektivitet i domænespecifikke opgaver. For eksempel foretrækker en finansiel virksomhed sin Q&A-bot til at hente svar fra sine seneste interne dokumenter, hvilket sikrer nøjagtighed og overholdelse af sine forretningsregler.
• Deres afhængighed af indlejret information kompromitterer fortolkningen.

For at bruge specifikke data i LLM'er findes der tre fremherskende metoder:

• Indlejring af data i modellen prompter, så den kan bruge denne kontekst under outputgenerering. Dette kan være nul-skud (ingen eksempler), få-skud (begrænsede eksempler) eller mange-skud (rigtige eksempler). Sådanne kontekstuelle tilskyndelser styrer modeller mod mere nuancerede resultater.
• Finjustering af modellen ved hjælp af par af prompter og afslutninger.
• RAG, som henter eksterne data (ikke-parametrisk) og integrerer disse data i prompterne, hvilket beriger konteksten.

Den første metode kæmper dog med modelbegrænsninger for kontekststørrelse, hvilket gør det svært at indtaste lange dokumenter og muligvis øger omkostningerne. Finjusteringstilgangen er, selvom den er potent, ressourcekrævende, især med eksterne data i konstant udvikling, hvilket fører til forsinkede implementeringer og øgede omkostninger. RAG kombineret med LLM'er tilbyder en løsning på de tidligere nævnte begrænsninger.

Retrieval Augmented Generation

RAG henter eksterne data (ikke-parametrisk) og integrerer disse data i ML-prompter, hvilket beriger konteksten. Lewis et al. introducerede RAG-modeller i 2020, og konceptualiserede dem som en sammensmeltning af en forudtrænet sekvens-til-sekvens-model (parametrisk hukommelse) og et tæt vektorindeks af Wikipedia (ikke-parametrisk hukommelse), der tilgås via en neural retriever.

Sådan fungerer RAG:

• Data kilder – RAG kan trække fra forskellige datakilder, herunder dokumentlagre, databaser eller API'er.
• Dataformatering – Både brugerens forespørgsel og dokumenterne omdannes til et format, der er egnet til relevanssammenligninger.
• indlejringerne – For at lette denne sammenligning transformeres forespørgslen og dokumentsamlingen (eller vidensbiblioteket) til numeriske indlejringer ved hjælp af sprogmodeller. Disse indlejringer indkapsler numerisk tekstbegreber.
• Relevanssøgning – Brugerforespørgslens indlejring sammenlignes med dokumentsamlingens indlejringer, hvilket identificerer relevant tekst gennem en lighedssøgning i indlejringsrummet.
• Kontekstberigelse – Den identificerede relevante tekst føjes til brugerens oprindelige prompt og forbedrer derved dens kontekst.
• LLM behandling – Med den berigede kontekst føres prompten til LLM, som på grund af medtagelsen af ​​relevante eksterne data producerer relevante og præcise output.
• Asynkrone opdateringer – For at sikre, at referencedokumenterne forbliver aktuelle, kan de opdateres asynkront sammen med deres indlejringsrepræsentationer. Dette sikrer, at fremtidige modelsvar er baseret på den nyeste information, hvilket garanterer nøjagtighed.

I det væsentlige tilbyder RAG en dynamisk metode til at tilføre LLM'er relevant information i realtid, hvilket sikrer generering af præcise og rettidige output.

Følgende diagram viser det konceptuelle flow ved at bruge RAG med LLM'er.

Løsningsoversigt

Følgende trin er påkrævet for at oprette et kontekstuelt spørgsmål, der besvarer chatbot til en applikation til finansielle tjenester:

1. Brug SageMaker JumpStart GPT-J-6B indlejringsmodellen til at generere indlejringer for hvert PDF-dokument i Amazon Simple Storage Service (Amazon S3) upload bibliotek.
2. Identificer relevante dokumenter ved at bruge følgende trin:
   • Generer en indlejring til brugerens forespørgsel ved hjælp af samme model.
   • Brug OpenSearch Serverless med vektormotorfunktionen til at søge efter de K mest relevante dokumentindekser i indlejringsområdet.
   • Hent de tilsvarende dokumenter ved hjælp af de identificerede indekser.
3. Kombiner de hentede dokumenter som kontekst med brugerens prompt og spørgsmål. Videresend dette til SageMaker LLM for generering af svar.

Vi bruger LangChain, en populær ramme, til at orkestrere denne proces. LangChain er specifikt designet til at understøtte applikationer drevet af LLM'er, og tilbyder en universel grænseflade til forskellige LLM'er. Det strømliner integrationen af ​​flere LLM'er, hvilket sikrer problemfri tilstandsvedholdenhed mellem opkald. Desuden øger det udviklereffektiviteten med funktioner som brugerdefinerbare promptskabeloner, omfattende applikationsbyggende agenter og specialiserede indekser til søgning og genfinding. For en dybdegående forståelse henvises til LangChain dokumentation.

Forudsætninger

Du har brug for følgende forudsætninger for at bygge vores kontekstbevidste chatbot:

For instruktioner om, hvordan man opsætter en OpenSearch Serverless vektormotor, se Vi introducerer vektormotoren til Amazon OpenSearch Serverless, nu i preview.

For en omfattende gennemgang af følgende løsning skal du klone GitHub repo og henvis til Jupyter notesbog.

Implementer ML-modellerne ved hjælp af SageMaker JumpStart

Udfør følgende trin for at implementere ML-modellerne:

1. Implementer Llama 2 LLM fra SageMaker JumpStart:

   from sagemaker.jumpstart.model import JumpStartModel
   llm_model = JumpStartModel(model_id = "meta-textgeneration-llama-2-7b-f")
   llm_predictor = llm_model.deploy()
   llm_endpoint_name = llm_predictor.endpoint_name

2. Implementer GPT-J-indlejringsmodellen:

   embeddings_model = JumpStartModel(model_id = "huggingface-textembedding-gpt-j-6b-fp16")
   embed_predictor = embeddings_model.deploy()
   embeddings_endpoint_name = embed_predictor.endpoint_name
   

Del data og opret et dokumentindlejringsobjekt

I dette afsnit deler du dataene i mindre dokumenter. Chunking er en teknik til at opdele store tekster i mindre bidder. Det er et væsentligt skridt, fordi det optimerer søgeforespørgslens relevans for vores RAG-model, hvilket igen forbedrer kvaliteten af ​​chatbotten. Klumpstørrelsen afhænger af faktorer som dokumenttypen og den anvendte model. En chunk chunk_size=1600 er blevet valgt, fordi dette er den omtrentlige størrelse af et afsnit. Efterhånden som modellerne forbedres, vil deres kontekstvinduestørrelse øges, hvilket giver mulighed for større chunkstørrelser.

Se i Jupyter notesbog i GitHub-reposen for den komplette løsning.

1. Forlæng LangChain SageMakerEndpointEmbeddings klasse for at oprette en brugerdefineret indlejringsfunktion, der bruger gpt-j-6b-fp16 SageMaker-slutpunktet, du oprettede tidligere (som en del af anvendelsen af ​​indlejringsmodellen):

   from langchain.embeddings import SagemakerEndpointEmbeddings
   from langchain.embeddings.sagemaker_endpoint import EmbeddingsContentHandler logger = logging.getLogger(__name__) # extend the SagemakerEndpointEmbeddings class from langchain to provide a custom embedding function
   class SagemakerEndpointEmbeddingsJumpStart(SagemakerEndpointEmbeddings): def embed_documents( self, texts: List[str], chunk_size: int = 1 ) → List[List[float]]: """Compute doc embeddings using a SageMaker Inference Endpoint. Args: texts: The list of texts to embed. chunk_size: The chunk size defines how many input texts will be grouped together as request. If None, will use the chunk size specified by the class. Returns: List of embeddings, one for each text. """ results = [] _chunk_size = len(texts) if chunk_size > len(texts) else chunk_size st = time.time() for i in range(0, len(texts), _chunk_size): response = self._embedding_func(texts[i : i + _chunk_size]) results.extend(response) time_taken = time.time() - st logger.info( f"got results for {len(texts)} in {time_taken}s, length of embeddings list is {len(results)}" ) print( f"got results for {len(texts)} in {time_taken}s, length of embeddings list is {len(results)}" ) return results # class for serializing/deserializing requests/responses to/from the embeddings model
   class ContentHandler(EmbeddingsContentHandler): content_type = "application/json" accepts = "application/json" def transform_input(self, prompt: str, model_kwargs={}) → bytes: input_str = json.dumps({"text_inputs": prompt, **model_kwargs}) return input_str.encode("utf-8") def transform_output(self, output: bytes) → str: response_json = json.loads(output.read().decode("utf-8")) embeddings = response_json["embedding"] if len(embeddings) == 1: return [embeddings[0]] return embeddings def create_sagemaker_embeddings_from_js_model( embeddings_endpoint_name: str, aws_region: str
   ) → SagemakerEndpointEmbeddingsJumpStart: content_handler = ContentHandler() embeddings = SagemakerEndpointEmbeddingsJumpStart( endpoint_name=embeddings_endpoint_name, region_name=aws_region, content_handler=content_handler, ) return embeddings 

2. Opret indlejringsobjektet og batch oprettelsen af ​​dokumentindlejringerne:

   embeddings = create_sagemaker_embeddings_from_js_model(embeddings_endpoint_name, aws_region)

3. Disse indlejringer gemmes i vektormotoren ved hjælp af LangChain OpenSearchVectorSearch. Du gemmer disse indlejringer i næste afsnit. Gem dokumentindlejringen i OpenSearch Serverless. Du er nu klar til at iterere over de chunkerede dokumenter, oprette indlejringerne og gemme disse indlejringer i OpenSearch Serverless vektorindeks, der er oprettet i vektorsøgningssamlinger. Se følgende kode:

   docsearch = OpenSearchVectorSearch.from_texts(
   texts = [d.page_content for d in docs],
   embedding=embeddings,
   opensearch_url=[{'host': _aoss_host, 'port': 443}],
   http_auth=awsauth,
   timeout = 300,
   use_ssl = True,
   verify_certs = True,
   connection_class = RequestsHttpConnection,
   index_name=_aos_index
   )

Spørgsmål og svar over dokumenter

Indtil videre har du delt et stort dokument i mindre, oprettet vektorindlejringer og gemt dem i en vektormotor. Nu kan du besvare spørgsmål vedrørende disse dokumentdata. Fordi du har oprettet et indeks over dataene, kan du lave en semantisk søgning; på denne måde videregives kun de mest relevante dokumenter, der kræves for at besvare spørgsmålet, via prompten til LLM. Dette giver dig mulighed for at spare tid og penge ved kun at sende relevante dokumenter til LLM. For flere detaljer om brug af dokumentkæder, se Dokumenter.

Udfør følgende trin for at besvare spørgsmål ved hjælp af dokumenterne:

1. For at bruge SageMaker LLM-endepunktet med LangChain, bruger du langchain.llms.sagemaker_endpoint.SagemakerEndpoint, som abstraherer SageMaker LLM-endepunktet. Du udfører en transformation for anmodnings- og svarnyttelasten som vist i følgende kode for LangChain SageMaker-integrationen. Bemærk, at du muligvis skal justere koden i ContentHandler baseret på content_type og accepterer formatet for den LLM-model, du vælger at bruge.

   content_type = "application/json"
   accepts = "application/json"
   def transform_input(self, prompt: str, model_kwargs: dict) → bytes: payload = { "inputs": [ [ { "role": "system", "content": prompt, }, {"role": "user", "content": prompt}, ], ], "parameters": { "max_new_tokens": 1000, "top_p": 0.9, "temperature": 0.6, }, } input_str = json.dumps( payload, ) return input_str.encode("utf-8") def transform_output(self, output: bytes) → str: response_json = json.loads(output.read().decode("utf-8")) content = response_json[0]["generation"]["content"] return content content_handler = ContentHandler() sm_jumpstart_llm=SagemakerEndpoint( endpoint_name=llm_endpoint_name, region_name=aws_region, model_kwargs={"max_new_tokens": 300}, endpoint_kwargs={"CustomAttributes": "accept_eula=true"}, content_handler=content_handler, )

Nu er du klar til at interagere med det finansielle dokument.

2. Brug følgende forespørgsels- og promptskabelon til at stille spørgsmål vedrørende dokumentet:

   from langchain import PromptTemplate, SagemakerEndpoint
   from langchain.llms.sagemaker_endpoint import LLMContentHandler query = "Summarize the earnings report and also what year is the report for"
   prompt_template = """Only use context to answer the question at the end. {context} Question: {question}
   Answer:""" prompt = PromptTemplate( template=prompt_template, input_variables=["context", "question"]
   ) class ContentHandler(LLMContentHandler): content_type = "application/json" accepts = "application/json" def transform_input(self, prompt: str, model_kwargs: dict) → bytes: payload = { "inputs": [ [ { "role": "system", "content": prompt, }, {"role": "user", "content": prompt}, ], ], "parameters": { "max_new_tokens": 1000, "top_p": 0.9, "temperature": 0.6, }, } input_str = json.dumps( payload, ) return input_str.encode("utf-8") def transform_output(self, output: bytes) → str: response_json = json.loads(output.read().decode("utf-8")) content = response_json[0]["generation"]["content"] return content content_handler = ContentHandler() chain = load_qa_chain( llm=SagemakerEndpoint( endpoint_name=llm_endpoint_name, region_name=aws_region, model_kwargs={"max_new_tokens": 300}, endpoint_kwargs={"CustomAttributes": "accept_eula=true"}, content_handler=content_handler, ), prompt=prompt,
   )
   sim_docs = docsearch.similarity_search(query, include_metadata=False)
   chain({"input_documents": sim_docs, "question": query}, return_only_outputs=True)
   

Ryd op

For at undgå fremtidige omkostninger skal du slette de SageMaker-slutningsendepunkter, som du har oprettet i denne notesbog. Du kan gøre det ved at køre følgende i din SageMaker Studio notesbog:

# Delete LLM
llm_predictor.delete_model()
llm_predictor.delete_predictor(delete_endpoint_config=True) # Delete Embeddings Model
embed_predictor.delete_model()
embed_predictor.delete_predictor(delete_endpoint_config=True)

Hvis du har oprettet en OpenSearch Serverless-samling til dette eksempel og ikke længere har brug for den, kan du slette den via OpenSearch Serverless-konsollen.

Konklusion

I dette indlæg diskuterede vi brugen af ​​RAG som en tilgang til at give domænespecifik kontekst til LLM'er. Vi viste, hvordan man bruger SageMaker JumpStart til at bygge en RAG-baseret kontekstuel chatbot til en finansiel serviceorganisation, der bruger Llama 2 og OpenSearch Serverless med en vektormotor som vektordatalager. Denne metode forfiner tekstgenerering ved hjælp af Llama 2 ved dynamisk at hente relevant kontekst. Vi er glade for at se dig bringe dine tilpassede data og innovere med denne RAG-baserede strategi på SageMaker JumpStart!

Om forfatterne

Sunil Padmanabhan er Startup Solutions Architect hos AWS. Som tidligere startup-stifter og CTO brænder han for machine learning og fokuserer på at hjælpe startups med at udnytte AI/ML til deres forretningsresultater og designe og implementere ML/AI-løsninger i stor skala.

Suleman Patel er Senior Solutions Architect hos Amazon Web Services (AWS), med særligt fokus på Machine Learning og Modernisering. Ved at udnytte sin ekspertise inden for både forretning og teknologi hjælper Suleman kunder med at designe og bygge løsninger, der tackler virkelige forretningsproblemer. Når han ikke er fordybet i sit arbejde, elsker Suleman at udforske naturen, tage på roadtrips og lave lækre retter i køkkenet.

• SEO Powered Content & PR Distribution. Bliv forstærket i dag.
• PlatoData.Network Vertical Generative Ai. Styrk dig selv. Adgang her.
• PlatoAiStream. Web3 intelligens. Viden forstærket. Adgang her.
• PlatoESG. Kulstof, CleanTech, Energi, Miljø, Solenergi, Affaldshåndtering. Adgang her.
• PlatoHealth. Bioteknologiske og kliniske forsøgs intelligens. Adgang her.
• Kilde: https://aws.amazon.com/blogs/machine-learning/build-a-contextual-chatbot-for-financial-services-using-amazon-sagemaker-jumpstart-llama-2-and-amazon-opensearch-serverless-with-vector-engine/