Kontextuális chatbot készítése pénzügyi szolgáltatásokhoz az Amazon SageMaker JumpStart, a Llama 2 és az Amazon OpenSearch Serverless és Vector Engine segítségével | Amazon webszolgáltatások

A pénzügyi szolgáltatási ágazat (FinServ) egyedi generatív mesterségesintelligencia-követelményekkel rendelkezik a tartományspecifikus adatokkal, az adatbiztonsággal, a szabályozási ellenőrzésekkel és az iparági megfelelőségi szabványokkal kapcsolatban. Ezenkívül az ügyfelek olyan lehetőségeket keresnek, amelyek segítségével kiválaszthatják a legteljesítményesebb és legköltséghatékonyabb gépi tanulási (ML) modellt, valamint az üzleti felhasználási eseteikhez igazodó szükséges testreszabási (finomhangolási) lehetőségeket. Amazon SageMaker JumpStart ideális a generatív mesterséges intelligencia felhasználási esetekre a FinServ ügyfelek számára, mivel biztosítja a szükséges adatbiztonsági ellenőrzéseket és megfelel a megfelelőségi szabványok követelményeinek.

Ebben a bejegyzésben a Retrieval Augmented Generation (RAG) alapú megközelítést és a SageMaker JumpStart nagy nyelvi modelljeit (LLM) használó kérdésmegválaszolási feladatokat mutatjuk be egy egyszerű pénzügyi tartomány használati esetével. A RAG egy keretrendszer a szöveggenerálás minőségének javítására az LLM és az információvisszakereső (IR) rendszer kombinálásával. Az LLM generált szöveget, és az IR rendszer a releváns információkat egy tudásbázisból kéri le. A visszakeresett információkat azután az LLM bemenetének kiegészítésére használják, ami segíthet a modell által generált szöveg pontosságának és relevanciájának javításában. A RAG hatékonynak bizonyult számos szöveggenerálási feladatnál, mint például a kérdések megválaszolása és az összegzés. Ígéretes megközelítés a szöveggeneráló modellek minőségének és pontosságának javítására.

A SageMaker JumpStart használatának előnyei

A SageMaker JumpStart segítségével az ML szakemberek a legmodernebb modellek széles választékából válogathatnak olyan felhasználási esetekre, mint a tartalomírás, képgenerálás, kódgenerálás, kérdések megválaszolása, szövegírás, összegzés, osztályozás, információkeresés stb. Az ML gyakorlói alapmodelleket telepíthetnek dedikált Amazon SageMaker példányokat egy hálózattól elszigetelt környezetből, és testreszabhatja a modelleket a SageMaker segítségével a modell betanítására és telepítésére.

A SageMaker JumpStart ideálisan alkalmas a FinServ ügyfelek generatív mesterséges intelligencia felhasználási eseteire, mivel a következőket kínálja:

• Testreszabási lehetőségek – A SageMaker JumpStart példajegyzetfüzeteket és részletes bejegyzéseket kínál az alapmodellek tartományi adaptációjához lépésről lépésre. Ezeket az erőforrásokat követheti az alapmodellek finomhangolásához, tartomány-adaptációjához és utasításaihoz, illetve RAG-alapú alkalmazások létrehozásához.
• Adatbiztonság – A következtetési hasznos adatok biztonságának biztosítása a legfontosabb. A SageMaker JumpStart segítségével a modelleket hálózati elszigeteltségben telepítheti, egyetlen bérlési végpont biztosításával. Ezenkívül kezelheti a kiválasztott modellekhez való hozzáférés-szabályozást a privát modellközpont funkción keresztül, igazodva az egyéni biztonsági követelményekhez.
• Szabályozási ellenőrzések és megfelelés – Az olyan szabványoknak való megfelelés, mint a HIPAA BAA, SOC123, PCI és HITRUST CSF, a SageMaker alapvető jellemzője, amely biztosítja a pénzügyi szektor szigorú szabályozási környezetéhez való igazodást.
• Modell választások – A SageMaker JumpStart a legkorszerűbb ML modellek választékát kínálja, amelyek folyamatosan a legjobbak közé tartoznak az iparágban elismert HELM-benchmarkok között. Ide tartoznak többek között a Llama 2, Falcon 40B, AI21 J2 Ultra, AI21 Summarize, Hugging Face MiniLM és BGE modellek.

Ebben a bejegyzésben egy kontextuális chatbot felépítését vizsgáljuk pénzügyi szolgáltató szervezetek számára, amelyek RAG architektúrát használnak a Llama 2 alapmodell és a Átölelhető arc GPTJ-6B-FP16 beágyazási modell, mindkettő elérhető a SageMaker JumpStartban. Mi is használjuk Vector motor mert Amazon OpenSearch kiszolgáló nélküli (jelenleg előnézetben), mint a vektoros adattár a beágyazások tárolására.

A nagy nyelvi modellek korlátai

Az LLM-eket hatalmas mennyiségű strukturálatlan adatra képezték ki, és kiválóak az általános szöveggenerálásban. Ezen a képzésen keresztül az LLM-ek tényszerű ismereteket szereznek és tárolnak. A kész LLM-ek azonban korlátozásokat tartalmaznak:

• Offline képzésük miatt nem vesznek tudomást a naprakész információkról.
• A túlnyomórészt általánosított adatokra vonatkozó képzésük csökkenti a szakterület-specifikus feladatokban való hatékonyságukat. Például egy pénzügyi cég előnyben részesítheti a Q&A botját, hogy a válaszokat a legújabb belső dokumentumaiból szerezze be, biztosítva ezzel a pontosságot és az üzleti szabályainak való megfelelést.
• A beágyazott információkra való támaszkodásuk veszélyezteti az értelmezhetőséget.

Konkrét adatok LLM-ekben való felhasználásához három elterjedt módszer létezik:

• Az adatok modellbe való beágyazása kéri, lehetővé téve a kontextus felhasználását a kimenet generálása során. Ez lehet zero-shot (nincs példa), néhány lövés (korlátozott példák) vagy sok lövés (bőséges példa). Az ilyen kontextuális felszólítás árnyaltabb eredmények felé tereli a modelleket.
• A modell finomhangolása promptok és kiegészítések páros használatával.
• RAG, amely lekéri a külső adatokat (nem paraméteres), és integrálja ezeket az adatokat a promptokba, gazdagítva a kontextust.

Az első módszer azonban megbirkózik a kontextusmérettel kapcsolatos modellkorlátokkal, ami megnehezíti a hosszadalmas dokumentumok bevitelét, és esetleg megnöveli a költségeket. A finomhangolási megközelítés, bár hatékony, erőforrás-igényes, különösen az állandóan változó külső adatok miatt, ami késleltetett telepítésekhez és megnövekedett költségekhez vezet. A RAG az LLM-ekkel kombinálva megoldást kínál a korábban említett korlátokra.

Visszakeresés kiterjesztett generáció

A RAG lekéri a külső adatokat (nem paraméteres), és ezeket az adatokat ML promptokba integrálja, gazdagítva a kontextust. Lewis et al. 2020-ban bevezette a RAG-modelleket, egy előre betanított szekvencia-szekvencia modell (paraméteres memória) és egy neurális retrieveren keresztül elérhető Wikipédia sűrű vektorindexének (nem-paraméteres memória) fúziójaként képzelve el őket.

A RAG működése a következő:

• Adatforrások – A RAG különféle adatforrásokból meríthet, beleértve a dokumentumtárakat, adatbázisokat vagy API-kat.
• Adatformázás – Mind a felhasználói lekérdezés, mind a dokumentumok a relevancia-összehasonlításra alkalmas formátumba kerülnek.
• embeddings – Az összehasonlítás megkönnyítése érdekében a lekérdezést és a dokumentumgyűjteményt (vagy tudástárat) nyelvi modellek segítségével numerikus beágyazásokká alakítják. Ezek a beágyazások numerikusan magukba foglalják a szöveges fogalmakat.
• Relevancia keresés – A felhasználói lekérdezés beágyazását a rendszer összehasonlítja a dokumentumgyűjtemény beágyazásaival, és a beágyazási területen végzett hasonlósági kereséssel azonosítja a releváns szöveget.
• Kontextus gazdagítása – Az azonosított releváns szöveget a felhasználó eredeti promptjához fűzi, javítva ezzel annak kontextusát.
• LLM feldolgozás – A kibővített kontextussal a prompt az LLM-be kerül, amely a releváns külső adatok bevonásával releváns és pontos kimeneteket produkál.
• Aszinkron frissítések – Annak érdekében, hogy a referenciadokumentumok naprakészek maradjanak, aszinkron módon frissíthetők a beágyazott ábrázolásaikkal együtt. Ez biztosítja, hogy a jövőbeli modellválaszok a legfrissebb információkon alapuljanak, garantálva a pontosságot.

Lényegében a RAG egy dinamikus módszert kínál az LLM-ek valós idejű, releváns információkkal való feltöltésére, biztosítva a pontos és időszerű kimenetek generálását.

A következő diagram bemutatja a RAG és az LLM-ekkel való használat fogalmi folyamatát.

Megoldás áttekintése

A következő lépések szükségesek ahhoz, hogy egy pénzügyi szolgáltatási alkalmazáshoz kontextuális kérdést megválaszoló chatbotot hozzon létre:

1. A SageMaker JumpStart GPT-J-6B beágyazási modell használatával hozzon létre beágyazást minden egyes PDF dokumentumhoz a Amazon egyszerű tárolási szolgáltatás (Amazon S3) feltöltési könyvtár.
2. Azonosítsa a releváns dokumentumokat a következő lépésekkel:
   • Hozzon létre beágyazást a felhasználó lekérdezéséhez ugyanazzal a modellel.
   • Használja az OpenSearch Serverless-t a vektormotor funkcióval, hogy megkeresse a K legfontosabb dokumentumindexet a beágyazási területen.
   • Keresse le a megfelelő dokumentumokat az azonosított indexek segítségével.
3. Kombinálja a letöltött dokumentumokat kontextusként a felhasználó kérdésével és kérdésével. Továbbítsa ezt a SageMaker LLM-nek válaszgenerálás céljából.

Ennek a folyamatnak a lebonyolítására a LangChaint, egy népszerű keretrendszert alkalmazzuk. A LangChaint kifejezetten az LLM-ek által működtetett alkalmazások támogatására tervezték, és univerzális interfészt kínál a különböző LLM-ek számára. Leegyszerűsíti a több LLM integrációját, biztosítva a zökkenőmentes állapot-megmaradást a hívások között. Ezenkívül olyan funkciókkal növeli a fejlesztők hatékonyságát, mint a testreszabható prompt sablonok, átfogó alkalmazásépítő ügynökök, valamint a kereséshez és visszakereséshez szükséges speciális indexek. A mélyreható megértéshez tekintse meg a LangChain dokumentáció.

Előfeltételek

A környezettudatos chatbotunk elkészítéséhez a következő előfeltételekre van szüksége:

Az OpenSearch kiszolgáló nélküli vektormotor beállításához lásd: Bemutatjuk az Amazon OpenSearch Serverless vektormotorját, most előnézetben.

A következő megoldás átfogó áttekintéséhez klónozza a GitHub repo és utaljon a Jupyter notebook.

Telepítse az ML modelleket a SageMaker JumpStart segítségével

Az ML modellek üzembe helyezéséhez hajtsa végre a következő lépéseket:

1. Telepítse a Llama 2 LLM-et a SageMaker JumpStartból:

   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. Telepítse a GPT-J beágyazási modellt:

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

Csoportosítsa az adatokat, és hozzon létre egy dokumentumbeágyazási objektumot

Ebben a szakaszban az adatokat kisebb dokumentumokra bonthatja. A darabolás a nagy szövegek kisebb darabokra bontásának módszere. Ez elengedhetetlen lépés, mert optimalizálja a keresési lekérdezés relevanciáját a RAG modellünkhöz, ami viszont javítja a chatbot minőségét. A darab mérete olyan tényezőktől függ, mint a dokumentum típusa és a használt modell. A darab chunk_size=1600 lett kiválasztva, mert ez egy bekezdés hozzávetőleges mérete. Ahogy a modellek javulnak, a kontextusablak mérete növekszik, ami nagyobb darabméreteket tesz lehetővé.

Utal Jupyter jegyzetfüzet a GitHub repóban a teljes megoldásért.

1. Hosszabbítsa meg a LangChaint SageMakerEndpointEmbeddings osztályt egy egyéni beágyazási függvény létrehozásához, amely a korábban létrehozott gpt-j-6b-fp16 SageMaker végpontot használja (a beágyazási modell alkalmazásának részeként):

   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. Hozd létre a beágyazási objektumot, és kötegesítse a dokumentumbeágyazások létrehozását:

   embeddings = create_sagemaker_embeddings_from_js_model(embeddings_endpoint_name, aws_region)

3. Ezek a beágyazások a vektormotorban tárolódnak a LangChain segítségével OpenSearchVectorSearch. Ezeket a beágyazásokat a következő részben tárolja. Tárolja a dokumentumbeágyazást az OpenSearch Serverlessben. Most már készen áll arra, hogy végigfusson a csonkolt dokumentumokon, létrehozza a beágyazásokat, és tárolja ezeket a beágyazásokat a vektorkereső gyűjteményekben létrehozott OpenSearch Serverless vektorindexben. Lásd a következő kódot:

   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
   )

Kérdések és válaszok dokumentumokon keresztül

Eddig egy nagy dokumentumot kisebbekre darabolt, vektoros beágyazásokat hozott létre, és tárolt egy vektormotorban. Most már válaszolhat a dokumentumadatokkal kapcsolatos kérdésekre. Mivel az adatok fölé indexet hozott létre, szemantikai keresést végezhet; így csak a kérdés megválaszolásához szükséges legrelevánsabb dokumentumok kerülnek a prompton keresztül az LLM-hez. Ezzel időt és pénzt takaríthat meg azzal, hogy csak a releváns dokumentumokat továbbítja az LLM-nek. A dokumentumláncok használatával kapcsolatos további részletekért lásd: dokumentumok.

A dokumentumok segítségével a kérdések megválaszolásához hajtsa végre az alábbi lépéseket:

1. A SageMaker LLM végpont LangChainnel való használatához használja langchain.llms.sagemaker_endpoint.SagemakerEndpoint, amely a SageMaker LLM végpontot absztrahálja. Transzformációt hajt végre a kérés és a válasz hasznos adata számára, a LangChain SageMaker integráció következő kódjában látható módon. Vegye figyelembe, hogy előfordulhat, hogy módosítania kell a kódot a ContentHandlerben a content_type és a használni kívánt LLM-modell elfogadási formátuma alapján.

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

Most készen áll a pénzügyi dokumentummal való interakcióra.

2. A dokumentummal kapcsolatos kérdések feltevéséhez használja a következő lekérdezést és prompt sablont:

   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)
   

Razzia

A jövőbeni költségek elkerülése érdekében törölje a SageMaker következtetési végpontokat, amelyeket ebben a jegyzetfüzetben hozott létre. Ezt úgy teheti meg, hogy futtassa a következőket a SageMaker Studio jegyzetfüzetében:

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

Ha létrehozott egy OpenSearch Serverless gyűjteményt ehhez a példához, és már nincs rá szüksége, törölheti az OpenSearch Serverless konzolon keresztül.

Következtetés

Ebben a bejegyzésben azt tárgyaltuk, hogy a RAG-t olyan megközelítésként használjuk, amellyel tartomány-specifikus kontextust biztosítunk az LLM-eknek. Megmutattuk, hogyan lehet a SageMaker JumpStart segítségével létrehozni egy RAG-alapú kontextuális chatbotot egy pénzügyi szolgáltató szervezet számára, amely Llama 2-t és OpenSearch Serverless-t használ, vektoros adattárolóként vektormotorral. Ez a módszer finomítja a szöveggenerálást a Llama 2 használatával a releváns kontextus dinamikus beszerzésével. Örömmel látjuk, hogy elhozza egyéni adatait, és újít a SageMaker JumpStart RAG-alapú stratégiájával!

A szerzőkről

Sunil Padmanabhan az AWS Startup Solutions építésze. Korábbi startup-alapítóként és technológiai igazgatóként szenvedélyesen rajong a gépi tanulásért, és arra összpontosít, hogy segítse az induló vállalkozásokat az AI/ML-nek az üzleti eredményeik hasznosításában, valamint az ML/AI-megoldások széles körű tervezésében és bevezetésében.

Suleman Patel az Amazon Web Services (AWS) vezető megoldástervezője, különös tekintettel a gépi tanulásra és modernizációra. Az üzleti és technológiai szakértelmét kihasználva Suleman segít ügyfeleinek olyan megoldások tervezésében és kivitelezésében, amelyek a valós üzleti világ problémáit kezelik. Amikor nem merül el a munkájában, Suleman szereti felfedezni a szabadban, kirándulásokat tenni, és finom ételeket főzni a konyhában.

• SEO által támogatott tartalom és PR terjesztés. Erősödjön még ma.
• PlatoData.Network Vertical Generative Ai. Erősítse meg magát. Hozzáférés itt.
• PlatoAiStream. Web3 Intelligence. Felerősített tudás. Hozzáférés itt.
• PlatoESG. Carbon, CleanTech, Energia, Környezet, Nap, Hulladékgazdálkodás. Hozzáférés itt.
• PlatoHealth. Biotechnológiai és klinikai vizsgálatok intelligencia. Hozzáférés itt.
• Forrás: 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/