בניית צ'אט בוט קונטקסטואלי לשירותים פיננסיים באמצעות Amazon SageMaker JumpStart, Llama 2 ו-Amazon OpenSearch ללא שרתים עם מנוע וקטור

הועלה מחדש על ידי אפלטון

עוקב: 0

לתעשיית השירותים הפיננסיים (FinServ) יש דרישות בינה מלאכותית ייחודיות הקשורות לנתונים ספציפיים לתחום, אבטחת מידע, בקרות רגולטוריות ותקני תאימות בתעשייה. בנוסף, לקוחות מחפשים אפשרויות לבחירת מודל למידת מכונה (ML) הביצועית והחסכונית ביותר ויכולת לבצע התאמה אישית (כיוונון עדין) הכרחית כדי להתאים למקרי השימוש העסקיים שלהם. אמזון SageMaker JumpStart מתאים באופן אידיאלי עבור מקרי שימוש בינה מלאכותית עבור לקוחות FinServ מכיוון שהוא מספק את בקרות אבטחת הנתונים הנדרשות ועומד בדרישות תקני התאימות.

בפוסט זה, אנו מדגימים משימות מענה לשאלות באמצעות גישה מבוססת Retrieval Augmented Generation (RAG) עם מודלים של שפות גדולות (LLMs) ב- SageMaker JumpStart באמצעות מקרה שימוש פשוט בדומיין פיננסי. RAG היא מסגרת לשיפור איכות יצירת הטקסט על ידי שילוב של LLM עם מערכת אחזור מידע (IR). הטקסט שנוצר ב-LLM, ומערכת ה-IR שואבת מידע רלוונטי מבסיס ידע. המידע המאוחזר משמש לאחר מכן להגדלת הקלט של ה-LLM, מה שיכול לעזור לשפר את הדיוק והרלוונטיות של הטקסט שנוצר במודל. RAG הוכח כיעיל עבור מגוון משימות יצירת טקסט, כגון מענה לשאלות וסיכום. זוהי גישה מבטיחה לשיפור האיכות והדיוק של מודלים ליצירת טקסט.

יתרונות השימוש ב- SageMaker JumpStart

עם SageMaker JumpStart, מתרגלי ML יכולים לבחור מתוך מבחר רחב של מודלים חדישים למקרי שימוש כגון כתיבת תוכן, הפקת תמונות, הפקת קוד, מענה לשאלות, קופירייטינג, סיכום, סיווג, אחזור מידע ועוד. מתרגלי ML יכולים לפרוס מודלים של בסיס למסורים אמזון SageMaker מופעים מסביבה מבודדת רשת והתאמה אישית של מודלים באמצעות SageMaker להדרכה ופריסה של מודלים.

SageMaker JumpStart מתאים באופן אידיאלי למקרי שימוש בינה מלאכותית עבור לקוחות FinServ מכיוון שהוא מציע את הדברים הבאים:

יכולות התאמה אישית – SageMaker JumpStart מספק מחברות לדוגמה ופוסטים מפורטים להדרכה שלב אחר שלב על התאמת תחום של מודלים של בסיס. אתה יכול לעקוב אחר משאבים אלה עבור כוונון עדין, התאמת תחום והדרכה של מודלים של בסיס או לבניית יישומים מבוססי RAG.
אבטחת מידע - הבטחת האבטחה של נתוני מטען מסקנות היא חשיבות עליונה. עם SageMaker JumpStart, אתה יכול לפרוס מודלים בבידוד רשת עם אספקת נקודת קצה לשכירות אחת. יתר על כן, אתה יכול לנהל בקרת גישה לדגמים נבחרים באמצעות יכולת רכזת הדגמים הפרטיים, תוך התאמה לדרישות האבטחה האישיות.
בקרות רגולטוריות ותאימות - עמידה בתקנים כגון HIPAA BAA, SOC123, PCI ו-HITRUST CSF היא תכונת ליבה של SageMaker, המבטיחה התאמה לנוף הרגולטורי הקפדני של המגזר הפיננסי.
בחירת דגם – SageMaker JumpStart מציעה מבחר של דגמי ML חדישים המדורגים באופן עקבי בין המובילים במדדים המוכרים בתעשייה של HELM. אלה כוללים, בין היתר, דגמי Llama 2, Falcon 40B, AI21 J2 Ultra, AI21 Summarize, Hugging Face MiniLM ו-BGE.

בפוסט זה, אנו בוחנים בניית צ'אט בוט קונטקסטואלי עבור ארגוני שירותים פיננסיים באמצעות ארכיטקטורת RAG עם מודל היסוד של Llama 2 וה- חיבוק פנים GPTJ-6B-FP16 דגם embeddings, שניהם זמינים ב- SageMaker JumpStart. אנחנו גם משתמשים מנוע וקטור ל Amazon OpenSearch ללא שרתים (כרגע בתצוגה מקדימה) כמאגר נתונים וקטור לאחסון הטבעות.

מגבלות של דגמי שפה גדולים

אנשי LLM הוכשרו על כמויות עצומות של נתונים לא מובנים ומצטיינים ביצירת טקסט כללי. באמצעות הכשרה זו, לימודי תואר שני רוכשים ומאחסנים ידע עובדתי. עם זאת, לימודי LLM מהמדף מציגים מגבלות:

ההכשרה הלא מקוונת שלהם הופכת אותם ללא מודעים למידע מעודכן.
ההכשרה שלהם על נתונים כלליים בעיקר מפחיתה את היעילות שלהם במשימות ספציפיות לתחום. לדוגמה, חברה פיננסית עשויה להעדיף את בוט השאלות והתשובות שלה כדי לקבל תשובות מהמסמכים הפנימיים העדכניים ביותר שלה, כדי להבטיח דיוק ועמידה בכללים העסקיים שלה.
ההסתמכות שלהם על מידע מוטבע פוגעת בפרשנות.

כדי להשתמש בנתונים ספציפיים בלימודי LLM, קיימות שלוש שיטות נפוצות:

הטבעת נתונים בתוך המודל מבקשות, מה שמאפשר לו לנצל את ההקשר הזה במהלך יצירת הפלט. זה יכול להיות ירי אפס (ללא דוגמאות), ירי מעט (דוגמאות מוגבלות), או ירי רבים (דוגמאות בשפע). הנחיה קונטקסטואלית כזו מכוונת מודלים לעבר תוצאות ניואנסיות יותר.
כוונון עדין של המודל באמצעות זוגות של הנחיות והשלמות.
RAG, המאחזרת נתונים חיצוניים (לא פרמטריים) ומשלבת נתונים אלו בהנחיות, ומעשירה את ההקשר.

עם זאת, השיטה הראשונה מתמודדת עם אילוצי מודל על גודל ההקשר, מה שהופך את זה לקשה להזין מסמכים ארוכים ואולי מגדיל את העלויות. גישת הכוונון העדין, למרות שהיא חזקה, היא עתירת משאבים, במיוחד עם נתונים חיצוניים המתפתחים כל הזמן, מה שמוביל לעיכוב בפריסות ועלויות מוגברות. RAG בשילוב עם LLMs מציע פתרון למגבלות שהוזכרו לעיל.

אחזור דור מוגבר

RAG מאחזר נתונים חיצוניים (לא פרמטריים) ומשלב נתונים אלה בהנחיות ML, ומעשיר את ההקשר. לואיס וחב'. הציג מודלים של RAG בשנת 2020, תוך שהוא משיג אותם כהיתוך של מודל רצף-לרצף מאומן מראש (זיכרון פרמטרי) ואינדקס וקטור צפוף של ויקיפדיה (זיכרון לא פרמטרי) שאליו ניתן לגשת באמצעות אחזור עצבי.

כך פועלת RAG:

מקורות מידע - RAG יכול לשאוב ממקורות נתונים מגוונים, כולל מאגרי מסמכים, מסדי נתונים או ממשקי API.
עיצוב נתונים – הן שאילתת המשתמש והן המסמכים הופכים לפורמט המתאים להשוואת רלוונטיות.
טבילות – כדי להקל על השוואה זו, השאילתה ואוסף המסמכים (או ספריית הידע) הופכים להטמעות מספריות באמצעות מודלים של שפה. הטמעות אלה עוטפות באופן מספרי מושגים טקסטואליים.
חיפוש רלוונטיות – הטמעת שאילתת המשתמש מושווה להטמעות אוסף המסמכים, מזהה טקסט רלוונטי באמצעות חיפוש דמיון במרחב ההטמעה.
העשרת הקשר – הטקסט הרלוונטי המזוהה מצורף להנחיה המקורית של המשתמש, ובכך משפר את ההקשר שלו.
עיבוד LLM – עם ההקשר המועשר, ההנחיה מוזנת ל-LLM, אשר, עקב הכללת נתונים חיצוניים רלוונטיים, מייצרת פלטים רלוונטיים ומדויקים.
עדכונים אסינכרוניים - כדי להבטיח שמסמכי ההתייחסות יישארו עדכניים, ניתן לעדכן אותם באופן אסינכרוני יחד עם ייצוגי ההטמעה שלהם. זה מבטיח שתגובות המודל העתידיות מבוססות על המידע העדכני ביותר, מה שמבטיח דיוק.

למעשה, RAG מציעה שיטה דינמית להחדיר ל- LLMs מידע רלוונטי בזמן אמת, תוך הבטחת יצירת פלטים מדויקים ובזמן.

התרשים הבא מציג את הזרימה הרעיונית של שימוש ב- RAG עם LLMs.

בניית צ'אט בוט קונטקסטואלי לשירותים פיננסיים באמצעות Amazon SageMaker JumpStart, Llama 2 ו-Amazon OpenSearch Serverless with Vector Engine | Amazon Web Services PlatoBlockchain Data Intelligence. חיפוש אנכי. איי.

סקירת פתרונות

השלבים הבאים נדרשים כדי ליצור שאלה בהקשר המענה לצ'אטבוט עבור יישום שירותים פיננסיים:

השתמש במודל ההטמעה של SageMaker JumpStart GPT-J-6B כדי ליצור הטבעות עבור כל מסמך PDF ב- שירות אחסון פשוט של אמזון (Amazon S3) ספריית העלאות.
זהה מסמכים רלוונטיים באמצעות השלבים הבאים:
- צור הטבעה עבור השאילתה של המשתמש באמצעות אותו מודל.
- השתמש ב-OpenSearch Serverless עם התכונה של מנוע וקטור כדי לחפש את ה-K האינדקסים המובילים של המסמכים הרלוונטיים ביותר במרחב ההטמעה.
- אחזר את המסמכים המתאימים באמצעות האינדקסים שזוהו.
שלב את המסמכים שאוחזרו כהקשר עם ההנחיה והשאלה של המשתמש. העבר את זה ל- SageMaker LLM ליצירת תגובה.

אנו מעסיקים את LangChain, מסגרת פופולרית, כדי לתזמר את התהליך הזה. LangChain תוכננה במיוחד כדי לחזק יישומים המופעלים על ידי LLMs, ומציעה ממשק אוניברסלי עבור LLMs שונים. זה מייעל את האינטגרציה של מספר LLMs, ומבטיח התמדה במצב חלק בין שיחות. יתר על כן, זה מגביר את יעילות המפתחים עם תכונות כמו תבניות הנחיות הניתנות להתאמה אישית, סוכנים מקיפים לבניית יישומים ואינדקסים מיוחדים לחיפוש ואחזור. להבנה מעמיקה, עיין ב תיעוד LangChain.

תנאים מוקדמים

אתה צריך את התנאים המוקדמים הבאים כדי לבנות את הצ'אט בוט שלנו המודע להקשר:

להנחיות כיצד להגדיר מנוע וקטור ללא שרת OpenSearch, עיין ב היכרות עם מנוע וקטור עבור Amazon OpenSearch Serverless, כעת בתצוגה מקדימה.

להדרכה מקיפה על הפתרון הבא, שיבוט את GitHub ריפו ועיין ב מחברת צדק.

פרוס את דגמי ה-ML באמצעות SageMaker JumpStart

כדי לפרוס את דגמי ה-ML, בצע את השלבים הבאים:

פרוס את ה-Llama 2 LLM מ- 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

פרוס את מודל ההטמעות של 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

חלק נתונים וצור אובייקט של הטבעת מסמך

בחלק זה, אתה מחלק את הנתונים למסמכים קטנים יותר. Chunking היא טכניקה לפיצול טקסטים גדולים לגושים קטנים יותר. זהו צעד חיוני מכיוון שהוא מייעל את הרלוונטיות של שאילתת החיפוש עבור מודל ה-RAG שלנו, אשר בתורו משפר את איכות הצ'אטבוט. גודל הנתח תלוי בגורמים כגון סוג המסמך והדגם המשמש. chunk chunk_size=1600 נבחר מכיוון שזהו הגודל המשוער של פסקה. ככל שהדגמים משתפרים, גודל חלון ההקשר שלהם יגדל, מה שמאפשר גדלי נתחים גדולים יותר.

עיין ב מחברת צדק ב-Repo GitHub לקבלת הפתרון המלא.

הארך את LangChain SageMakerEndpointEmbeddings מחלקה ליצירת פונקציית הטמעות מותאמת אישית המשתמשת בנקודת הקצה gpt-j-6b-fp16 SageMaker שיצרת קודם לכן (כחלק מהשימוש במודל ההטמעות):

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

צור את אובייקט ההטמעות ויצירת הטמעות המסמכים באצווה:
```
embeddings = create_sagemaker_embeddings_from_js_model(embeddings_endpoint_name, aws_region)
```
הטמעות אלו מאוחסנות במנוע הווקטור באמצעות LangChain OpenSearchVectorSearch. אתה מאחסן את ההטבעות האלה בסעיף הבא. אחסן את הטבעת המסמך ב-OpenSearch Serverless. כעת אתה מוכן לחזור על המסמכים המשובצים, ליצור את ההטבעות ולאחסן את ההטמעות הללו באינדקס הווקטור ללא שרת OpenSearch שנוצר באוספים של חיפוש וקטור. ראה את הקוד הבא:
```
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
)
```

שאלות ומענה על מסמכים

עד כה, חיברתם מסמך גדול לקטנים יותר, יצרתם הטבעות וקטוריות ואחסנתם במנוע וקטור. כעת תוכל לענות על שאלות בנוגע לנתוני המסמך. מכיוון שיצרת אינדקס על הנתונים, אתה יכול לבצע חיפוש סמנטי; בדרך זו, רק המסמכים הרלוונטיים ביותר הנדרשים כדי לענות על השאלה מועברים דרך ההנחיה ל-LLM. זה מאפשר לך לחסוך זמן וכסף רק על ידי העברת מסמכים רלוונטיים ל-LLM. לפרטים נוספים על שימוש בשרשרת מסמכים, עיין ב דוחות.

בצע את השלבים הבאים כדי לענות על שאלות באמצעות המסמכים:

כדי להשתמש בנקודת הקצה SageMaker LLM עם LangChain, אתה משתמש langchain.llms.sagemaker_endpoint.SagemakerEndpoint, אשר מפשט את נקודת הקצה SageMaker LLM. אתה מבצע טרנספורמציה עבור מטען הבקשה והתגובה כפי שמוצג בקוד הבא עבור שילוב LangChain SageMaker. שים לב שייתכן שתצטרך להתאים את הקוד ב-ContentHandler בהתבסס על הפורמט content_type ומקבל של מודל ה-LLM שבו תבחר להשתמש.

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

עכשיו אתה מוכן לקיים אינטראקציה עם המסמך הפיננסי.

השתמש בשאילתה ובתבנית הבקשה הבאה כדי לשאול שאלות בנוגע למסמך:

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)

ניקוי

כדי למנוע עלויות עתידיות, מחק את נקודות הסיום של SageMaker שיצרת במחברת זו. אתה יכול לעשות זאת על ידי הפעלת הדברים הבאים במחברת SageMaker Studio שלך:

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

אם יצרת אוסף OpenSearch Serverless עבור דוגמה זו וכבר אינך זקוק לו, תוכל למחוק אותו דרך מסוף OpenSearch Serverless.

סיכום

בפוסט זה, דנו בשימוש ב- RAG כגישה לספק הקשר ספציפי לתחום ל-LLMs. הראינו כיצד להשתמש ב- SageMaker JumpStart כדי לבנות צ'אט בוט מבוסס RAG עבור ארגון שירותים פיננסיים המשתמשים ב-Llama 2 ו-OpenSearch Serverless עם מנוע וקטור כמאגר נתונים וקטור. שיטה זו משכללת את יצירת הטקסט באמצעות Llama 2 על ידי מיקור דינמי של הקשר רלוונטי. אנו נרגשים לראות אותך מביא את הנתונים המותאמים אישית שלך ומתחדשים עם אסטרטגיה זו מבוססת RAG ב- SageMaker JumpStart!

על המחברים

סוניל פדמנאבהן הוא אדריכל פתרונות סטארט-אפ ב-AWS. כמייסד סטארט-אפ ו-CTO לשעבר, הוא נלהב מלמידת מכונה ומתמקד בסיוע לסטארט-אפים למנף AI/ML לתוצאות העסקיות שלהם ולתכנן ולפרוס פתרונות ML/AI בקנה מידה.

סולימן פאטל הוא ארכיטקט פתרונות בכיר בחברת Amazon Web Services (AWS), עם התמקדות מיוחדת בלמידת מכונה ומודרניזציה. ממנף את המומחיות שלו הן בעסק והן בטכנולוגיה, סולימן עוזר ללקוחות לעצב ולבנות פתרונות המתמודדים עם בעיות עסקיות בעולם האמיתי. כשהוא לא שקוע בעבודתו, סולימן אוהב לחקור את החוץ, לצאת לטיולים ולבשל מנות טעימות במטבח.