Zgradite kontekstualni chatbot za finančne storitve z uporabo Amazon SageMaker JumpStart, Llama 2 in Amazon OpenSearch Serverless with Vector Engine | Spletne storitve Amazon

Industrija finančnih storitev (FinServ) ima edinstvene generativne zahteve umetne inteligence, povezane s podatki, specifičnimi za domeno, varnostjo podatkov, regulativnim nadzorom in standardi skladnosti industrije. Poleg tega stranke iščejo možnosti za izbiro najzmogljivejšega in stroškovno učinkovitega modela strojnega učenja (ML) ter zmožnost izvajanja potrebnih prilagoditev (fine nastavitve), da ustrezajo njihovim poslovnim primerom uporabe. Amazon SageMaker JumpStart je idealen za generativne primere uporabe umetne inteligence za stranke FinServ, ker zagotavlja potrebne kontrole varnosti podatkov in izpolnjuje zahteve standardov skladnosti.

V tej objavi prikazujemo naloge odgovarjanja na vprašanja z uporabo pristopa, ki temelji na RAG (Retrieval Augmented Generation) z velikimi jezikovnimi modeli (LLM) v SageMaker JumpStart z uporabo preprostega primera uporabe finančne domene. RAG je ogrodje za izboljšanje kakovosti generiranja besedila s kombinacijo LLM s sistemom za iskanje informacij (IR). LLM ustvari besedilo, sistem IR pa pridobi ustrezne informacije iz baze znanja. Pridobljene informacije se nato uporabijo za povečanje vnosa LLM, kar lahko pomaga izboljšati natančnost in ustreznost besedila, ustvarjenega z modelom. RAG se je izkazal za učinkovitega pri različnih nalogah ustvarjanja besedila, kot sta odgovarjanje na vprašanja in povzemanje. To je obetaven pristop za izboljšanje kakovosti in natančnosti modelov za generiranje besedila.

Prednosti uporabe SageMaker JumpStart

S SageMaker JumpStart lahko praktiki ML izbirajo med širokim naborom najsodobnejših modelov za primere uporabe, kot so pisanje vsebine, ustvarjanje slik, ustvarjanje kode, odgovarjanje na vprašanja, pisanje besedil, povzemanje, klasifikacija, iskanje informacij in več. Strokovnjaki ML lahko uvedejo temeljne modele v namenske Amazon SageMaker primerke iz omrežno izoliranega okolja in prilagodite modele z uporabo SageMakerja za usposabljanje in uvajanje modelov.

SageMaker JumpStart je idealen za generativne primere uporabe AI za stranke FinServ, saj ponuja naslednje:

• Zmožnosti prilagajanja – SageMaker JumpStart ponuja primere zvezkov in podrobne objave za navodila po korakih za prilagajanje domene modelov temeljev. Sledite tem virom za natančno nastavitev, prilagoditev domene in navodila za temeljne modele ali za izdelavo aplikacij, ki temeljijo na RAG.
• Varnost podatkov – Zagotavljanje varnosti podatkov koristnega tovora sklepanja je najpomembnejše. S SageMaker JumpStart lahko uvedete modele v omrežni izolaciji z zagotavljanjem končne točke z enim najemom. Poleg tega lahko upravljate nadzor dostopa do izbranih modelov prek zmogljivosti zvezdišča zasebnega modela, pri čemer se uskladite s posameznimi varnostnimi zahtevami.
• Regulativni nadzor in skladnost – Skladnost s standardi, kot so HIPAA BAA, SOC123, PCI in HITRUST CSF, je osrednja značilnost SageMakerja, ki zagotavlja usklajenost s strogimi regulativnimi okviri finančnega sektorja.
• Izbira modela – SageMaker JumpStart ponuja izbor najsodobnejših modelov ML, ki se dosledno uvrščajo med najboljše v industrijsko priznanih merilih uspešnosti HELM. Ti vključujejo, vendar niso omejeni na modele Llama 2, Falcon 40B, AI21 J2 Ultra, AI21 Summarize, Hugging Face MiniLM in BGE.

V tej objavi raziskujemo gradnjo kontekstualnega klepetalnika za organizacije finančnih storitev z uporabo arhitekture RAG s temeljnim modelom Llama 2 in Objemni obraz GPTJ-6B-FP16 model vdelav, oba sta na voljo v SageMaker JumpStart. Uporabljamo tudi Vektorski motor za Amazon OpenSearch brez strežnika (trenutno v predogledu) kot shrambo vektorskih podatkov za shranjevanje vdelav.

Omejitve velikih jezikovnih modelov

LLM-ji so bili usposobljeni za velike količine nestrukturiranih podatkov in so odlični pri ustvarjanju splošnega besedila. S tem usposabljanjem LLM pridobijo in shranijo dejansko znanje. Vendar imajo standardni LLM omejitve:

• Njihovo usposabljanje brez povezave povzroči, da ne poznajo posodobljenih informacij.
• Njihovo usposabljanje na pretežno posplošenih podatkih zmanjšuje njihovo učinkovitost pri domensko specifičnih nalogah. Na primer, finančno podjetje bi morda raje uporabljalo svojega bota za vprašanja in odgovore, če bi odgovore dobilo iz svojih najnovejših notranjih dokumentov, s čimer bi zagotovilo točnost in skladnost s svojimi poslovnimi pravili.
• Njihovo zanašanje na vgrajene informacije ogroža interpretabilnost.

Za uporabo določenih podatkov v LLM obstajajo tri prevladujoče metode:

• Vdelava podatkov v pozive modela, ki omogoča uporabo tega konteksta med ustvarjanjem izhodnih podatkov. To je lahko ničelno (brez primerov), malokratno (omejeni primeri) ali večkratno (veliko primerov). Takšno kontekstualno spodbujanje usmerja modele k bolj niansiranim rezultatom.
• Natančna nastavitev modela z uporabo parov pozivov in dokončanj.
• RAG, ki pridobi zunanje podatke (neparametrične) in te podatke integrira v pozive ter obogati kontekst.

Vendar se prva metoda spopada z omejitvami modela glede velikosti konteksta, zaradi česar je težko vnašati dolge dokumente in morda poveča stroške. Čeprav je pristop natančnega prilagajanja močan, zahteva veliko virov, zlasti z nenehno razvijajočimi se zunanjimi podatki, kar vodi do zakasnjenih uvajanj in povečanih stroškov. RAG v kombinaciji z LLM ponuja rešitev za prej omenjene omejitve.

Povečana generacija pridobivanja

RAG pridobi zunanje podatke (neparametrične) in te podatke integrira v pozive ML, s čimer obogati kontekst. Lewis et al. je leta 2020 uvedel modele RAG in jih konceptualiziral kot fuzijo vnaprej naučenega modela zaporedja do zaporedja (parametrični pomnilnik) in gostega vektorskega indeksa Wikipedije (neparametrični pomnilnik), do katerega dostopate prek nevronskega prinašalca.

Takole deluje RAG:

• Viri podatkov – RAG lahko črpa iz različnih virov podatkov, vključno z repozitoriji dokumentov, bazami podatkov ali API-ji.
• Oblikovanje podatkov – Uporabnikova poizvedba in dokumenti se pretvorijo v obliko, primerno za relevantne primerjave.
• Vdelave – Da bi olajšali to primerjavo, se poizvedba in zbirka dokumentov (ali knjižnica znanja) pretvorita v numerične vdelave z uporabo jezikovnih modelov. Te vdelave numerično povzemajo besedilne koncepte.
• Iskanje ustreznosti – Vdelava uporabniške poizvedbe se primerja z vdelavami zbirke dokumentov, pri čemer se identificira ustrezno besedilo z iskanjem podobnosti v prostoru za vdelavo.
• Obogatitev konteksta – Identificirano ustrezno besedilo je dodano izvirnemu pozivu uporabnika, s čimer se izboljša njegov kontekst.
• LLM obdelava – Z obogatenim kontekstom se poziv napaja v LLM, ki zaradi vključitve ustreznih zunanjih podatkov ustvari ustrezne in natančne rezultate.
• Asinhrone posodobitve – Za zagotovitev, da referenčni dokumenti ostanejo posodobljeni, jih je mogoče asinhrono posodobiti skupaj z njihovimi vdelanimi predstavitvami. To zagotavlja, da prihodnji odzivi modela temeljijo na najnovejših informacijah, kar zagotavlja natančnost.

V bistvu RAG ponuja dinamično metodo za vlaganje LLM-jev z ustreznimi informacijami v realnem času, kar zagotavlja ustvarjanje natančnih in pravočasnih rezultatov.

Naslednji diagram prikazuje konceptualni potek uporabe RAG z LLM.

Pregled rešitev

Za ustvarjanje kontekstualnega klepetalnega robota za odgovore na vprašanja za aplikacijo finančnih storitev so potrebni naslednji koraki:

1. Uporabite model vdelave SageMaker JumpStart GPT-J-6B za ustvarjanje vdelav za vsak dokument PDF v Preprosta storitev shranjevanja Amazon (Amazon S3) imenik za nalaganje.
2. Identificirajte ustrezne dokumente z naslednjimi koraki:
   • Ustvarite vdelavo za uporabnikovo poizvedbo z uporabo istega modela.
   • Uporabite OpenSearch Serverless s funkcijo vektorskega mehanizma za iskanje najboljših K najpomembnejših indeksov dokumentov v prostoru za vdelavo.
   • Pridobite ustrezne dokumente z uporabo identificiranih indeksov.
3. Združite pridobljene dokumente kot kontekst z uporabnikovim pozivom in vprašanjem. Posredujte to SageMaker LLM za ustvarjanje odgovora.

Za usmerjanje tega procesa uporabljamo LangChain, priljubljeno ogrodje. LangChain je posebej zasnovan za krepitev aplikacij, ki jih poganjajo LLM, in ponuja univerzalni vmesnik za različne LLM. Poenostavlja integracijo več LLM-jev in zagotavlja brezhibno obstojnost stanja med klici. Poleg tega povečuje učinkovitost razvijalcev s funkcijami, kot so prilagodljive predloge pozivov, celoviti agenti za gradnjo aplikacij in specializirani indeksi za iskanje in priklic. Za poglobljeno razumevanje glejte Dokumentacija LangChain.

Predpogoji

Potrebujete naslednje predpogoje za izdelavo našega kontekstualno zaznavnega chatbota:

Za navodila o tem, kako nastaviti vektorski mehanizem OpenSearch Serverless, glejte Predstavljamo vektorski mehanizem za Amazon OpenSearch Serverless, zdaj v predogledu.

Za celovito predstavitev naslednje rešitve klonirajte GitHub repo in se nanašajo na Jupyterjev zvezek.

Razmestite modele ML z uporabo SageMaker JumpStart

Za uvedbo modelov ML izvedite naslednje korake:

1. Razmestite Llama 2 LLM iz 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. Razmestite model vdelav GPT-J:

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

Razdelite podatke in ustvarite objekt vdelave dokumenta

V tem razdelku podatke razdelite na manjše dokumente. Chunking je tehnika za razdeljevanje velikih besedil na manjše dele. To je bistven korak, saj optimizira ustreznost iskalne poizvedbe za naš model RAG, kar posledično izboljša kakovost chatbota. Velikost kosov je odvisna od dejavnikov, kot sta vrsta dokumenta in uporabljeni model. Izbran je bil del chunk_size=1600, ker je to približna velikost odstavka. Ko se modeli izboljšujejo, se bo povečala velikost njihovega kontekstnega okna, kar bo omogočilo večje velikosti kosov.

Glejte Jupyterjev zvezek v repo GitHub za popolno rešitev.

1. Razširite LangChain SageMakerEndpointEmbeddings razred za ustvarjanje funkcije vdelav po meri, ki uporablja končno točko gpt-j-6b-fp16 SageMaker, ki ste jo ustvarili prej (kot del uporabe modela vdelav):

   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. Ustvarite predmet vdelav in paketno ustvarite vdelave dokumentov:

   embeddings = create_sagemaker_embeddings_from_js_model(embeddings_endpoint_name, aws_region)

3. Te vdelave so shranjene v vektorskem mehanizmu z uporabo LangChain OpenSearchVectorSearch. Te vdelave shranite v naslednjem razdelku. Shranite vdelavo dokumenta v OpenSearch Serverless. Zdaj ste pripravljeni na iteracijo po razdeljenih dokumentih, ustvarjanje vdelav in shranjevanje teh vdelav v brezstrežniškem vektorskem indeksu OpenSearch, ustvarjenem v zbirkah vektorskega iskanja. Oglejte si naslednjo kodo:

   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
   )

Vprašanje in odgovarjanje na dokumente

Do sedaj ste velik dokument razdelili na manjše, ustvarili vektorske vdelave in jih shranili v vektorski mehanizem. Zdaj lahko odgovorite na vprašanja v zvezi s temi podatki dokumenta. Ker ste nad podatki ustvarili indeks, lahko izvedete semantično iskanje; na ta način se le najustreznejši dokumenti, ki so potrebni za odgovor na vprašanje, posredujejo prek poziva LLM. To vam omogoča, da prihranite čas in denar, tako da LLM posredujete samo ustrezne dokumente. Za več podrobnosti o uporabi verig dokumentov glejte dokumenti.

Izpolnite naslednje korake, da odgovorite na vprašanja z uporabo dokumentov:

1. Za uporabo končne točke SageMaker LLM z LangChain uporabite langchain.llms.sagemaker_endpoint.SagemakerEndpoint, ki abstrahira končno točko SageMaker LLM. Izvedete transformacijo koristnega tovora zahteve in odgovora, kot je prikazano v naslednji kodi za integracijo LangChain SageMaker. Upoštevajte, da boste morda morali prilagoditi kodo v ContentHandlerju glede na content_type in sprejemljivo obliko modela LLM, ki ga izberete.

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

Zdaj ste pripravljeni na interakcijo s finančnim dokumentom.

2. Za zastavljanje vprašanj v zvezi z dokumentom uporabite naslednjo predlogo poizvedbe in poziva:

   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)
   

Pospravi

Da se izognete prihodnjim stroškom, izbrišite končne točke sklepanja SageMaker, ki ste jih ustvarili v tem zvezku. To lahko storite tako, da v svojem prenosniku SageMaker Studio zaženete naslednje:

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

Če ste za ta primer ustvarili zbirko OpenSearch Serverless in je ne potrebujete več, jo lahko izbrišete prek konzole OpenSearch Serverless.

zaključek

V tej objavi smo razpravljali o uporabi RAG kot pristopu za zagotavljanje domensko specifičnega konteksta za LLM. Pokazali smo, kako uporabiti SageMaker JumpStart za izdelavo kontekstualnega klepetalnika, ki temelji na RAG, za organizacijo finančnih storitev z uporabo Llama 2 in OpenSearch Serverless z vektorskim mehanizmom kot shrambo vektorskih podatkov. Ta metoda izboljša ustvarjanje besedila z uporabo Llame 2 z dinamičnim iskanjem ustreznega konteksta. Navdušeni smo, ko vidimo, da prinašate svoje podatke po meri in uvajate inovacije s to strategijo, ki temelji na RAG, na SageMaker JumpStart!

O avtorjih

Sunil Padmanabhan je arhitekt za zagonske rešitve pri AWS. Kot nekdanji ustanovitelj zagonskega podjetja in tehnični direktor se navdušuje nad strojnim učenjem in se osredotoča na pomoč zagonskim podjetjem pri uporabi AI/ML za njihove poslovne rezultate ter načrtovanju in uvajanju rešitev ML/AI v velikem obsegu.

Suleman Patel je višji arhitekt rešitev pri Amazon Web Services (AWS) s posebnim poudarkom na strojnem učenju in modernizaciji. Z izkoriščanjem svojega strokovnega znanja na področju poslovanja in tehnologije Suleman strankam pomaga oblikovati in zgraditi rešitve, ki se spopadajo s poslovnimi težavami v resničnem svetu. Kadar ni zatopljen v delo, Suleman rad raziskuje na prostem, se odpravi na izlete in kuha okusne jedi v kuhinji.

• Distribucija vsebine in PR s pomočjo SEO. Okrepite se še danes.
• PlatoData.Network Vertical Generative Ai. Opolnomočite se. Dostopite tukaj.
• PlatoAiStream. Web3 Intelligence. Razširjeno znanje. Dostopite tukaj.
• PlatoESG. Ogljik, CleanTech, Energija, Okolje, sončna energija, Ravnanje z odpadki. Dostopite tukaj.
• PlatoHealth. Obveščanje o biotehnologiji in kliničnih preskušanjih. Dostopite tukaj.
• vir: 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/