פרוס דגמי יסוד עם Amazon SageMaker, חזור על וניטור עם TruEra | שירותי האינטרנט של אמזון

הבלוג הזה נכתב בשיתוף עם ג'וש רייני, שיאק סן ואנופאם דאטה מ-TruEra

אמזון SageMaker JumpStart מספק מגוון דגמי יסודות מאומנים מראש כגון Llama-2 ו-Mistal 7B שניתן לפרוס במהירות לנקודת קצה. מודלים בסיסיים אלה מתפקדים היטב עם משימות יצירתיות, החל מיצירת טקסט וסיכומים, מענה על שאלות וכלה בהפקת תמונות וסרטונים. למרות יכולות ההכללה הנהדרות של מודלים אלו, לעיתים קרובות ישנם מקרי שימוש בהם יש להתאים מודלים אלו למשימות או לתחומים חדשים. אחת הדרכים להעלות את הצורך הזה היא על ידי הערכת המודל מול מערך נתונים של אמת קרקע אוצרת. לאחר שהצורך להתאים את מודל הבסיס ברור, אתה יכול להשתמש בסט של טכניקות כדי לבצע זאת. גישה פופולרית היא לכוונן את המודל באמצעות מערך נתונים המותאם למקרה השימוש. כוונון עדין יכול לשפר את מודל הבסיס וניתן למדוד את יעילותו שוב מול מערך הנתונים של האמת הבסיסית. זֶה מחברה מראה כיצד לכוונן דגמים עם SageMaker JumpStart.

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

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

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

TruEra בערימת האפליקציות של LLM

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

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

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

פרוס דגמי יסוד ב- SageMaker

אתה יכול לפרוס דגמי יסוד כגון Llama-2 ב- SageMaker עם שתי שורות בלבד של קוד Python:

from sagemaker.jumpstart.model import JumpStartModel
pretrained_model = JumpStartModel(model_id="meta-textgeneration-llama-2-7b")
pretrained_predictor = pretrained_model.deploy()

הפעל את נקודת הקצה של הדגם

לאחר הפריסה, אתה יכול להפעיל את נקודת הקצה של המודל הפרוס על ידי יצירת תחילה מטען המכיל את התשומות ואת פרמטרי המודל שלך:

payload = { "inputs": "I believe the meaning of life is", "parameters": { "max_new_tokens": 64, "top_p": 0.9, "temperature": 0.6, "return_full_text": False, },
}

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

response = pretrained_predictor.predict(payload, custom_attributes="accept_eula=true")

הערכת ביצועים עם TruLens

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

from trulens_eval import Bedrock
# Initialize AWS Bedrock feedback function collection class:
provider = Bedrock(model_id = "amazon.titan-tg1-large", region_name="us-east-1")

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

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

רלוונטיות ההקשר

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

f_context_relevance = (Feedback(provider.relevance, name = "Context Relevance") .on(Select.Record.calls[0].args.args[0]) .on(Select.Record.calls[0].args.args[1]) )

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

מקורקעות

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

grounded = Groundedness(groundedness_provider=provider) f_groundedness = (Feedback(grounded.groundedness_measure, name = "Groundedness") .on(Select.Record.calls[0].args.args[1]) .on_output() .aggregate(grounded.grounded_statements_aggregator) )

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

רלוונטיות התשובה

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

f_answer_relevance = (Feedback(provider.relevance, name = "Answer Relevance") .on(Select.Record.calls[0].args.args[0]) .on_output() )

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

הערכת אמת קרקעית

בנוסף לפונקציות המשוב הללו לזיהוי הזיות, יש לנו מערך בדיקה, DataBricks-Dolly-15k, שמאפשר לנו להוסיף דמיון אמתי כמדד הערכה רביעי. ראה את הקוד הבא:

from datasets import load_dataset dolly_dataset = load_dataset("databricks/databricks-dolly-15k", split="train") # To train for question answering/information extraction, you can replace the assertion in next line to example["category"] == "closed_qa"/"information_extraction".
summarization_dataset = dolly_dataset.filter(lambda example: example["category"] == "summarization")
summarization_dataset = summarization_dataset.remove_columns("category") # We split the dataset into two where test data is used to evaluate at the end.
train_and_test_dataset = summarization_dataset.train_test_split(test_size=0.1) # Rename columns
test_dataset = pd.DataFrame(test_dataset)
test_dataset.rename(columns={"instruction": "query"}, inplace=True) # Convert DataFrame to a list of dictionaries
golden_set = test_dataset[["query","response"]].to_dict(orient='records') # Create a Feedback object for ground truth similarity
ground_truth = GroundTruthAgreement(golden_set)
# Call the agreement measure on the instruction and output
f_groundtruth = (Feedback(ground_truth.agreement_measure, name = "Ground Truth Agreement") .on(Select.Record.calls[0].args.args[0]) .on_output() )

בנה את האפליקציה

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

def base_llm(instruction, context): # For instruction fine-tuning, we insert a special key between input and output input_output_demarkation_key = "nn### Response:n" payload = { "inputs": template["prompt"].format( instruction=instruction, context=context ) + input_output_demarkation_key, "parameters": {"max_new_tokens": 200}, } return pretrained_predictor.predict( payload, custom_attributes="accept_eula=true" )[0]["generation"]

לאחר שיצרת את האפליקציה ואת פונקציות המשוב, זה פשוט ליצור אפליקציה עטופה עם TruLens. היישום העטוף הזה, שאנו קוראים לו base_recorder, ירשום ויעריך את היישום בכל פעם שהוא נקרא:

base_recorder = TruBasicApp(base_llm, app_id="Base LLM", feedbacks=[f_groundtruth, f_answer_relevance, f_context_relevance, f_groundedness]) for i in range(len(test_dataset)): with base_recorder as recording: base_recorder.app(test_dataset["query"][i], test_dataset["context"][i])

תוצאות עם בסיס לאמה-2

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

כוונן עדין את Llama-2 באמצעות SageMaker Jumpstart

שלבים לכוונון עדין של דגם Llama-2 באמצעות SageMaker Jumpstart מסופקים גם כאן מחברה.

כדי להגדיר כוונון עדין, תחילה עליך להוריד את ערכת ההדרכה ולהגדיר תבנית להוראות

# Dumping the training data to a local file to be used for training.
train_and_test_dataset["train"].to_json("train.jsonl") import json template = { "prompt": "Below is an instruction that describes a task, paired with an input that provides further context. " "Write a response that appropriately completes the request.nn" "### Instruction:n{instruction}nn### Input:n{context}nn", "completion": " {response}",
}
with open("template.json", "w") as f: json.dump(template, f)

לאחר מכן, העלה גם את מערך הנתונים וגם ההוראות ל-an שירות אחסון פשוט של אמזון (Amazon S3) דלי לאימון:

from sagemaker.s3 import S3Uploader
import sagemaker
import random output_bucket = sagemaker.Session().default_bucket()
local_data_file = "train.jsonl"
train_data_location = f"s3://{output_bucket}/dolly_dataset"
S3Uploader.upload(local_data_file, train_data_location)
S3Uploader.upload("template.json", train_data_location)
print(f"Training data: {train_data_location}")

כדי לכוונן את SageMaker, אתה יכול להשתמש ב-SageMaker JumpStart Estimator. אנו משתמשים כאן בעיקר בהיפרפרמטרים המוגדרים כברירת מחדל, אלא שהגדרנו את כוונון ההוראות ל-true:

from sagemaker.jumpstart.estimator import JumpStartEstimator estimator = JumpStartEstimator( model_id=model_id, environment={"accept_eula": "true"}, disable_output_compression=True, # For Llama-2-70b, add instance_type = "ml.g5.48xlarge"
)
# By default, instruction tuning is set to false. Thus, to use instruction tuning dataset you use
estimator.set_hyperparameters(instruction_tuned="True", epoch="5", max_input_length="1024")
estimator.fit({"training": train_data_location})

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

finetuned_predictor = estimator.deploy() def finetuned_llm(instruction, context): # For instruction fine-tuning, we insert a special key between input and output input_output_demarkation_key = "nn### Response:n" payload = { "inputs": template["prompt"].format( instruction=instruction, context=context ) + input_output_demarkation_key, "parameters": {"max_new_tokens": 200}, } return finetuned_predictor.predict( payload, custom_attributes="accept_eula=true" )[0]["generation"] finetuned_recorder = TruBasicApp(finetuned_llm, app_id="Finetuned LLM", feedbacks=[f_groundtruth, f_answer_relevance, f_context_relevance, f_groundedness])

הערך את המודל המכוונן

אתה יכול להפעיל את המודל שוב על ערכת הבדיקה שלך ולראות את התוצאות, הפעם בהשוואה ל-Llama-2 הבסיס:

for i in range(len(test_dataset)): with finetuned_recorder as recording: finetuned_recorder.app(test_dataset["query"][i], test_dataset["context"][i]) tru.get_leaderboard(app_ids=[‘Base LLM’,‘Finetuned LLM’])

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

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

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

לדוגמה, אם אתה שואל את ה-LLM הבסיסי את השאלה "מהו מנוע ה-Flat six של פורשה החזק ביותר", הדגם הוזה את הדברים הבאים.

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

אם אתה מייצא את אותו רשומה עבור ה-LLM המכוונן שלך ב-TruLens, אתה יכול לראות שכוונון עדין עם SageMaker JumpStart שיפר באופן דרמטי את הבסיסיות של התגובה.

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

איך TruLens עובד

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

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

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

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

הערך עבור תגובות כנות, לא מזיקות ומועילות

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

סיכום

פוסט זה דן כיצד אתה יכול להאיץ את ייצור יישומי הבינה המלאכותית ולהשתמש במודלים של בסיס בארגון שלך. עם SageMaker JumpStart, Amazon Bedrock ו-TruEra, אתה יכול לפרוס, לכוונן ולחזור על דגמי יסוד עבור יישום ה-LLM שלך. תבדוק את זה קישור למידע נוסף על TruEra ולנסות את  מחברה עַצמְךָ.

על המחברים

ג'וש רייני הוא תורם ליבה ל-TruLens בקוד פתוח ולמדען המייסד של קשרי מפתחים ב-TruEra, שם הוא אחראי על יוזמות חינוך וטיפוח קהילה משגשגת של מתרגלי איכות בינה מלאכותית.

שיאק סנ הוא ה-CTO והמייסד המשותף של TruEra. Shayak מתמקדת בבניית מערכות ובהובלת מחקר כדי להפוך מערכות למידת מכונה לניתנות להסבר, תואמות פרטיות והוגנות יותר.

אנופם דאטה הוא מייסד שותף, נשיא ומדען ראשי של TruEra. לפני TruEra, הוא בילה 15 שנים בפקולטה באוניברסיטת קרנגי מלון (2007-22), לאחרונה כפרופסור קבוע להנדסת חשמל ומחשבים ומדעי המחשב.

Vivek Gangasani הוא ארכיטקט פתרונות AI/ML לסטארט-אפים בינה מלאכותית ב-AWS. הוא עוזר לסטארט-אפים מתעוררים של GenAI לבנות פתרונות חדשניים באמצעות שירותי AWS ומחשוב מואץ. נכון לעכשיו, הוא מתמקד בפיתוח אסטרטגיות לכוונון עדין ואופטימיזציה של ביצועי ההסקה של מודלים של שפה גדולה. בזמנו הפנוי, ויווק נהנה לטייל, לצפות בסרטים ולנסות מאכלים שונים.

• הפצת תוכן ויחסי ציבור מופעל על ידי SEO. קבל הגברה היום.
• PlatoData.Network Vertical Generative Ai. העצים את עצמך. גישה כאן.
• PlatoAiStream. Web3 Intelligence. הידע מוגבר. גישה כאן.
• PlatoESG. פחמן, קלינטק, אנרגיה, סביבה, שמש, ניהול פסולת. גישה כאן.
• PlatoHealth. מודיעין ביוטכנולוגיה וניסויים קליניים. גישה כאן.
• מקור: https://aws.amazon.com/blogs/machine-learning/deploy-foundation-models-with-amazon-sagemaker-iterate-and-monitor-with-truera/