ארוז ופריסה ML ו-LLMs קלאסיים בקלות עם Amazon SageMaker, חלק 1: שיפורים ב- PySDK | שירותי האינטרנט של אמזון

אמזון SageMaker הוא שירות מנוהל במלואו המאפשר למפתחים ולמדעני נתונים לבנות, לאמן ולפרוס מודלים של למידת מכונה (ML) במהירות וללא מאמץ בכל קנה מידה. SageMaker עושה את זה פשוט לפרוס מודלים לייצור ישירות באמצעות קריאות API לשירות. מודלים נארזים במכולות לפריסות חזקות וניתנות להרחבה. למרות שהוא מספק נקודות כניסה שונות כמו SageMaker Python SDK, AWS SDKs, קונסולת SageMaker, ו סטודיו SageMaker של אמזון מחברות כדי לפשט את תהליך ההכשרה והפריסה של מודלים של ML בקנה מידה, לקוחות עדיין מחפשים דרכים טובות יותר לפרוס את המודלים שלהם לבדיקת מגרש משחקים ולמטב פריסות ייצור.

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

בפוסט זה, אנו מציגים את ה- SageMaker Python SDK החדש ModelBuilder ניסיון, שמטרתו למזער את עקומת הלמידה עבור משתמשי SageMaker חדשים כמו מדעני נתונים, ובמקביל לסייע למהנדסי MLOps מנוסים למקסם את השימוש בשירותי האירוח של SageMaker. זה מפחית את המורכבות של ההגדרה והפריסה הראשונית, ועל ידי מתן הנחיות לגבי שיטות עבודה מומלצות לניצול מלוא היכולות של SageMaker. אנו מספקים מידע מפורט ודוגמאות GitHub עבור יכולת SageMaker החדשה הזו.

ההשקה החדשה הנוספת היא שימוש בחוויית הפריסה האינטראקטיבית החדשה ב-SageMaker Studio. אנחנו דנים בזה בחלק השני.

פריסת מודלים לנקודת קצה של SageMaker כרוכה בסדרה של שלבים כדי להכין את המודל להתארח בנקודת קצה של SageMaker. זה כרוך בהשגת חפצי הדגם בפורמט ובמבנה הנכונים, יצירת קוד מסקנות וציון פרטים חיוניים כמו כתובת ה-URL של תמונת הדגם, שירות אחסון פשוט של אמזון (Amazon S3) מיקום של חפצי מודל, שלבי הסידרה והסידריאליזציה, והכרחי AWS זהות וניהול גישה (IAM) תפקידים כדי להקל על הרשאות גישה מתאימות. לאחר מכן, תצורת נקודת קצה דורשת קביעת סוג ההסקה והגדרת פרמטרים מתאימים כגון סוגי מופעים, ספירות וחלוקת תעבורה בין גרסאות המודל.

כדי לעזור ללקוחותינו עוד יותר בעת השימוש באירוח של SageMaker, הצגנו את החדש ModelBuilder מחלקה ב-SageMaker Python SDK, אשר מביאה את היתרונות העיקריים הבאים בעת פריסת מודלים לנקודות קצה של SageMaker:

• מאחד את חווית הפריסה בין מסגרות - החוויה החדשה מספקת זרימת עבודה עקבית לפריסת מודלים שנבנו באמצעות מסגרות שונות כמו PyTorch, TensorFlow ו-XGBoost. זה מפשט את תהליך הפריסה.
• הופך את פריסת המודל לאוטומטי - משימות כמו בחירת קונטיינרים מתאימים, לכידת תלות וטיפול בסריאליזציה/הסידריאליזציה הן אוטומטיות, ומפחיתות את המאמץ הידני הנדרש לפריסה.
• מספק מעבר חלק מנקודת קצה מקומית ל- SageMaker מתארח - עם שינויי קוד מינימליים, ניתן להעביר מודלים בקלות מבדיקה מקומית לפריסה בנקודת קצה של SageMaker. יומנים חיים הופכים את ניפוי הבאגים לחלק.

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

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

היכרות עם SageMaker ModelBuilder

DELETE THIS ModelBuilder הוא כיתת Python המתמקדת בלקיחת מודלים של ML שנבנו באמצעות מסגרות, כמו XGBoost או PyTorch, והמרתם למודלים שמוכנים לפריסה ב- SageMaker. ModelBuilder מספק build() פונקציה, המייצרת את החפצים בהתאם לשרת הדגם, ו- a deploy() פונקציה לפריסה מקומית או לנקודת קצה של SageMaker. הצגת תכונה זו מפשטת את האינטגרציה של מודלים עם סביבת SageMaker, וממטבת אותם לביצועים ומדרגיות. התרשים הבא מראה כיצד ModelBuilder עובד ברמה גבוהה.

כיתת ModelBuilder

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

class ModelBuilder( model, # model id or model object role_arn, # IAM role schema_builder, # defines the input and output mode, # select between local deployment and depoy to SageMaker Endpoints ...
)

SchemaBuilder

השמיים SchemaBuilder class מאפשרת לך להגדיר את הקלט והפלט עבור נקודת הקצה שלך. היא מאפשרת לבונה הסכימה ליצור את פונקציות ה-marshaling המתאימות להסדרה וסיריאליזציה של הקלט והפלט. קובץ הכיתה הבא מספק את כל האפשרויות להתאמה אישית:

class SchemaBuilder( sample_input: Any, sample_output: Any, input_translator: CustomPayloadTranslator = None, output_translator: CustomPayloadTranslator = None
)

עם זאת, ברוב המקרים, רק קלט ופלט לדוגמה יעבדו. לדוגמה:

input = "How is the demo going?"
output = "Comment la démo va-t-elle?"
schema = SchemaBuilder(input, output)

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

חווית מצב מקומי

בדוגמה זו אנו משתמשים ModelBuilder לפרוס את מודל XGBoost באופן מקומי. אתה יכול להשתמש במצב כדי לעבור בין בדיקה מקומית לפריסה לנקודת קצה של SageMaker. תחילה אנו מאמנים את דגם XGBoost (מקומי או ב- SageMaker) ומאחסנים את חפצי הדגם בספריית העבודה:

# Train the model
model = XGBClassifier()
model.fit(X_train, y_train)
model.save_model(model_dir + "/my_model.xgb")

לאחר מכן אנו יוצרים אובייקט ModelBuilder על ידי העברת אובייקט הדגם בפועל, ה SchemaBuilder שמשתמש באובייקטי הקלט והפלט לדוגמה של הבדיקה (אותו קלט ופלט שהשתמשנו בהם בעת אימון ובדיקת המודל) כדי להסיק את ההסדרה הדרושה. שימו לב שאנו משתמשים Mode.LOCAL_CONTAINER כדי לציין פריסה מקומית. לאחר מכן, אנו מתקשרים ל- לִבנוֹת פונקציה לזיהוי אוטומטי של תמונת מיכל המסגרת הנתמכת וכן לסרוק לאיתור תלות. ראה את הקוד הבא:

model_builder_local = ModelBuilder( model=model, schema_builder=SchemaBuilder(X_test, y_pred), role_arn=execution_role, mode=Mode.LOCAL_CONTAINER
)
xgb_local_builder = model_builder_local.build()

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

# note: all the serialization and deserialization is handled by the model builder.
predictor_local = xgb_local_builder.deploy(
# instance_type='ml.c5.xlarge',
# initial_instance_count=1
) # Make prediction for test data. predictor_local.predict(X_test)

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

עיין ב model-builder-xgboost.ipynb דוגמה לבדיקת פריסה הן מקומית והן לנקודת קצה של SageMaker באמצעות ModelBuilder.

פרוס מודלים מסורתיים לנקודות הקצה של SageMaker

בדוגמאות הבאות, אנו מציגים כיצד להשתמש ModelBuilder לפרוס דגמי ML מסורתיים.

דגמי XGBoost

בדומה לסעיף הקודם, אתה יכול לפרוס מודל XGBoost לנקודת קצה של SageMaker על ידי שינוי mode פרמטר בעת יצירת ה ModelBuilder אובייקט:

model_builder = ModelBuilder( model=model, schema_builder=SchemaBuilder(sample_input=sample_input, sample_output=sample_output), role_arn=execution_role, mode=Mode.SAGEMAKER_ENDPOINT
)
xgb_builder = model_builder.build()
predictor = xgb_builder.deploy( instance_type='ml.c5.xlarge', initial_instance_count=1
)

שים לב שבפריסה לנקודות קצה של SageMaker, עליך לציין את סוג המופע וספירת המופעים בעת קריאה ל- deploy פונקציה.

עיין ב model-builder-xgboost.ipynb דוגמה לפריסת מודל XGBoost.

דגמי טריטון

אתה יכול להשתמש ModelBuilder לשרת דגמי PyTorch שרת מסקנות טריטון. בשביל זה, אתה צריך לציין את model_server פרמטר כ ModelServer.TRITON, להעביר דגם, ולהיות א SchemaBuilder אובייקט, הדורש כניסות ופלטים לדוגמה מהמודל. ModelBuilder ידאג לכל השאר בשבילך.

model_builder = ModelBuilder( model=model, schema_builder=SchemaBuilder(sample_input=sample_input, sample_output=sample_output), role_arn=execution_role, model_server=ModelServer.TRITON, mode=Mode.SAGEMAKER_ENDPOINT
) triton_builder = model_builder.build() predictor = triton_builder.deploy( instance_type='ml.g4dn.xlarge', initial_instance_count=1
)

עיין model-builder-triton.ipynb לפרוס מודל עם טריטון.

דוגמניות פייס מחבקות

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

# custom inference spec with hugging face pipeline
class MyInferenceSpec(InferenceSpec): def load(self, model_dir: str): return pipeline("translation_en_to_fr", model="t5-small") def invoke(self, input, model): return model(input) inf_spec = MyInferenceSpec()

אנו גם מגדירים את הקלט והפלט של עומס העבודה בהסקת ההסקה על ידי הגדרת ה SchemaBuilder אובייקט המבוסס על הקלט והפלט של המודל:

schema = SchemaBuilder(value,output)

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

builder = ModelBuilder( inference_spec=inf_spec, mode=Mode.SAGEMAKER_ENDPOINT, # you can change it to Mode.LOCAL_CONTAINER for local testing schema_builder=schema, image_uri=image,
)
model = builder.build( role_arn=execution_role, sagemaker_session=sagemaker_session,
)
predictor = model.deploy( initial_instance_count=1, instance_type='ml.g5.2xlarge'
)

עיין model-builder-huggingface.ipynb לפרוס דגם צינור של Hugging Face.

פרוס מודלים של בסיס לנקודות הקצה של SageMaker

בדוגמאות הבאות, אנו מציגים כיצד להשתמש ModelBuilder לפרוס דגמי יסוד. בדיוק כמו הדגמים שהוזכרו קודם לכן, כל מה שנדרש הוא מזהה הדגם.

חיבוק Face Hub

אם אתה רוצה לפרוס מודל יסוד מ חיבוק Face Hub, כל מה שאתה צריך לעשות הוא להעביר את מזהה הדגם המאומן מראש. לדוגמה, קטע הקוד הבא פורס את ה- meta-llama/Llama-2-7b-hf דגם מקומי. אתה יכול לשנות את המצב ל Mode.SAGEMAKER_ENDPOINT לפרוס לנקודות קצה של SageMaker.

model_builder = ModelBuilder( model="meta-llama/Llama-2-7b-hf", schema_builder=SchemaBuilder(sample_input, sample_output), model_path="/home/ec2-user/SageMaker/LoadTestResources/meta-llama2-7b", #local path where artifacts will be saved mode=Mode.LOCAL_CONTAINER, env_vars={ # Llama 2 is a gated model and requires a Hugging Face Hub token. "HUGGING_FACE_HUB_TOKEN": "<YourHuggingFaceToken>" }
)
model = model_builder.build()
local_predictor = model.deploy()

עבור דגמים סגורים ב-Hugging Face Hub, עליך לבקש גישה דרך Hugging Face Hub ולהשתמש במפתח המשויך על ידי העברתו כמשתנה הסביבה HUGGING_FACE_HUB_TOKEN. חלק מדגמי Hugging Face עשויים לדרוש קוד מרחוק מהימן. ניתן להגדיר אותו כמשתנה סביבה גם באמצעות HF_TRUST_REMOTE_CODE. כברירת מחדל, ModelBuilder ישתמש ב-Huging Face Text Generation Inference (TGI) מיכל כמיכל הבסיסי לדגמי Hugging Face. אם תרצה להשתמש ב-AWS Large Model Inference (LMI) מכולות, אתה יכול להגדיר את model_server פרמטר כ ModelServer.DJL_SERVING כאשר אתה מגדיר את ModelBuilder אובייקט.

תכונה מסודרת של ModelBuilder היא היכולת להפעיל כוונון מקומי של פרמטרי המיכל בעת השימוש LOCAL_CONTAINER מצב. ניתן להשתמש בתכונה זו על ידי הפעלה פשוטה tuned_model = model.tune().

עיין demo-model-builder-huggingface-llama2.ipynb לפרוס דגם Hugging Face Hub.

SageMaker JumpStart

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

model_builder = ModelBuilder( model="huggingface-llm-falcon-7b-bf16", schema_builder=SchemaBuilder(sample_input, sample_output), role_arn=execution_role
) sm_ep_model = model_builder.build() predictor = sm_ep_model.deploy()

לכל מזהי הדגמים הזמינים של SageMaker JumpStart, עיין ב אלגוריתמים מובנים עם טבלת מודל מיומנת מראש. מתייחס model-builder-jumpstart-falcon.ipynb לפרוס מודל של SageMaker JumpStart.

מרכיב היסק

ModelBulder מאפשר לך להשתמש ביכולת רכיבי ההסקה החדשה ב- SageMaker כדי לפרוס מודלים. למידע נוסף על רכיבי מסקנות, ראה הפחת את עלויות פריסת המודל ב-50% בממוצע באמצעות התכונות האחרונות של SageMaker. אתה יכול להשתמש ברכיבי מסקנות לפריסה איתם ModelBuilder על ידי ציון endpoint_type=EndpointType.INFERENCE_COMPONENT_BASED ב deploy() שיטה. אתה יכול גם להשתמש ב tune() שיטה, אשר מביאה את המספר האופטימלי של מאיצים, ולשנות אותה במידת הצורך.

resource_requirements = ResourceRequirements( requests={ "num_accelerators": 4, "memory": 1024, "copies": 1, }, limits={},
) goldfinch_predictor_2 = model_2.deploy( mode=Mode.SAGEMAKER_ENDPOINT, endpoint_type=EndpointType.INFERENCE_COMPONENT_BASED, ... )

עיין model-builder-inference-component.ipynb לפרוס מודל כרכיב מסקנות.

התאם אישית את מחלקת ModelBuilder

השמיים ModelBuilder class מאפשרת לך להתאים אישית את טעינת המודל באמצעות InferenceSpec.

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

InferenceSpec

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

class InferenceSpec(abc.ABC): @abc.abstractmethod def load(self, model_dir: str): pass @abc.abstractmethod def invoke(self, input_object: object, model: object): pass

הקוד הבא מציג דוגמה לשימוש במחלקה זו:

class MyInferenceSpec(InferenceSpec): def load(self, model_dir: str): return // model object def invoke(self, input, model): return model(input)

CustomPayload Translator

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

1. סידור בקשת הסקת מסקנות (מטופל על ידי הלקוח)
2. הסרת בקשת הסקת הסקה (מטופלת על ידי השרת או האלגוריתם)
3. הפעלת הדגם כנגד המטען
4. שולח מטען תגובה בחזרה
5. הסדרת תגובת הסקה (מטופלת על ידי השרת או האלגוריתם)
6. דה-סריאליזציה של תגובת מסקנות (מטופל על ידי הלקוח)

הדיאגרמה הבאה מציגה את תהליך ההסדרה והדה-סריאליזציה במהלך תהליך הפנייה.

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

from sagemaker.serve import CustomPayloadTranslator # request translator
class MyRequestTranslator(CustomPayloadTranslator): # This function converts the payload to bytes - happens on client side def serialize_payload_to_bytes(self, payload: object) -> bytes: # converts the input payload to bytes ... ... return //return object as bytes # This function converts the bytes to payload - happens on server side def deserialize_payload_from_stream(self, stream) -> object: # convert bytes to in-memory object ... ... return //return in-memory object # response translator class MyResponseTranslator(CustomPayloadTranslator): # This function converts the payload to bytes - happens on server side def serialize_payload_to_bytes(self, payload: object) -> bytes: # converts the response payload to bytes ... ... return //return object as bytes # This function converts the bytes to payload - happens on client side def deserialize_payload_from_stream(self, stream) -> object: # convert bytes to in-memory object ... ... return //return in-memory object

ב demo-model-builder-pytorch.ipynb מחברת, אנו מדגימים כיצד לפרוס בקלות מודל PyTorch לנקודת קצה של SageMaker באמצעות ModelBuilder עם CustomPayloadTranslator ו InferenceSpec מעמד.

מודל שלב לפריסה

אם אתה רוצה לביים את המודל להסקת מסקנות או ברישום המודלים, אתה יכול להשתמש model.create() or model.register(). המודל המופעל נוצר בשירות, ולאחר מכן תוכל לפרוס מאוחר יותר. ראה את הקוד הבא:

model_builder = ModelBuilder( model=model, schema_builder=SchemaBuilder(X_test, y_pred), role_arn=execution_role, )
deployable_model = model_builder.build() deployable_model.create() # deployable_model.register() for model registry

השתמש במכולות מותאמות אישית

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

כדי להשתמש בתמונת מיכל משלך במקרה זה, עליך להגדיר את השדות image_uri ו model_server כאשר מגדירים ModelBuilder:

model_builder = ModelBuilder( model=model, # Pass in the actual model object. its "predict" method will be invoked in the endpoint. schema_builder=SchemaBuilder(X_test, y_pred), # Pass in a "SchemaBuilder" which will use the sample test input and output objects to infer the serialization needed. role_arn=execution_role, image_uri=image_uri, # REQUIRED FOR BYOC: Passing in image hosted in personal ECR Repo model_server=ModelServer.TORCHSERVE, # REQUIRED FOR BYOC: Passing in model server of choice mode=Mode.SAGEMAKER_ENDPOINT, dependencies={"auto": True, "custom": ["protobuf==3.20.2"]}
)

הנה ה image_uri תהיה תמונת המכולה ARN המאוחסנת בחשבונך מרשם מיכל אלסטי של אמזון מאגר (Amazon ECR). דוגמה אחת מוצגת כך:

# Pulled the xgboost:1.7-1 DLC and pushed to personal ECR repo
image_uri = "<your_account_id>.dkr.ecr.us-west-2.amazonaws.com/my-byoc:xgb"

כאשר image_uri מוגדר, במהלך ModelBuilder תהליך הבנייה, הוא ידלג על זיהוי אוטומטי של התמונה כאשר ה-URI של התמונה יסופק. אם model_server לא מוגדר ב-ModelBuilder, תקבל הודעת שגיאת אימות, לדוגמה:

ValueError: Model_server must be set when image_uri is set. Supported model servers: {<ModelServer.TRITON: 5>, <ModelServer.DJL_SERVING: 4>, <ModelServer.TORCHSERVE: 1>}

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

תלות מותאמות אישית

כשאתה רץ ModelBuilder.build(), כברירת מחדל הוא לוכד אוטומטית את סביבת Python שלך לתוך a requirements.txt קובץ ומתקין את אותה תלות במיכל. עם זאת, לפעמים סביבת Python המקומית שלך תתנגש עם הסביבה במיכל. ModelBuilder מספק דרך פשוטה עבורך לשנות את התלות שנלכדה כדי לתקן התנגשויות תלות כאלה על ידי כך שתאפשר לך לספק את התצורות המותאמות אישית שלך לתוך ModelBuilder. שימו לב שזה רק עבור TorchServe ו-Triton עם InferenceSpec. לדוגמה, אתה יכול לציין את תלות פרמטר הקלט, שהוא מילון Python, ב-ModelBuilder באופן הבא:

dependency_config = { "auto" = True, "requirements" = "/path/to/your/requirements.txt" "custom" = ["module>=1.2.3,<1.5", "boto3==1.16.*", "some_module@http://some/url"]
} ModelBuilder( # Other params dependencies=dependency_config,
).build()

אנו מגדירים את השדות הבאים:

• המכונית - האם לנסות ללכוד אוטומטית את התלות בסביבה שלך.
• דרישות - מחרוזת של השביל שלך requirements.txt קוֹבֶץ. (זה אופציונלי.)
• מנהג – רשימה של תלות מותאמות אישית אחרות שברצונך להוסיף או לשנות. (זה אופציונלי.)

אם אותו מודול מצוין במספר מקומות, custom אם כך, תהיה העדיפות הגבוהה ביותר requirements, ו auto תהיה בעדיפות נמוכה ביותר. לדוגמה, נניח שבמהלך זיהוי אוטומטי, ModelBuilder מזהה numpy==1.25ו requirements.txt מסופק קובץ המפרט numpy>=1.24,<1.26. בנוסף, יש תלות מותאמת אישית: custom = ["numpy==1.26.1"]. במקרה הזה, numpy==1.26.1 ייבחר כאשר נתקין תלויות בקונטיינר.

לנקות את

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

predictor.delete_model()
predictor.delete_endpoint()

סיכום

היכולת החדשה של SageMaker ModelBuilder מפשטת את התהליך של פריסת דגמי ML לייצור ב- SageMaker. על ידי טיפול ברבים מהפרטים המורכבים מאחורי הקלעים, ModelBuilder מפחית את עקומת הלמידה עבור משתמשים חדשים וממקסם את הניצול עבור משתמשים מנוסים. עם מספר שורות קוד בלבד, אתה יכול לפרוס מודלים עם מסגרות מובנות כמו XGBoost, PyTorch, Triton ו- Hugging Face, כמו גם מודלים שסופקו על ידי SageMaker JumpStart לתוך נקודות קצה חזקות וניתנות להרחבה ב- SageMaker.

אנו מעודדים את כל משתמשי SageMaker לנסות את היכולת החדשה על ידי הפניה ל- בונה מודלים דף תיעוד. ModelBuilder זמין כעת לכל משתמשי SageMaker ללא תשלום נוסף. נצל את זרימת העבודה הפשוטה הזו כדי לפרוס את הדגמים שלך מהר יותר. אנו מצפים לשמוע כיצד ModelBuilder מאיץ את מחזור חיי פיתוח המודל שלך!

תודה מיוחדת ל-Sirisha Upadhyayala, Raymond Liu, Gary Wang, Dhawal Patel, Deepak Garg ו-Ram Vegiraju.

על המחברים

מלאני לי, PhD, הוא TAM מומחה בינה מלאכותית/ML בכיר ב-AWS שבסיסו בסידני, אוסטרליה. היא עוזרת ללקוחות ארגוניים לבנות פתרונות תוך שימוש בכלי AI/ML מתקדמים ב-AWS ומספקת הדרכה לגבי ארכיטקטורה והטמעה של פתרונות ML עם שיטות עבודה מומלצות. בזמנה הפנוי היא אוהבת לחקור את הטבע ולבלות עם משפחה וחברים.

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

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

ראגו רמשה הוא אדריכל בכיר ML Solutions בצוות Amazon SageMaker Service. הוא מתמקד בסיוע ללקוחות לבנות, לפרוס ולהעביר עומסי עבודה של ייצור ML ל-SageMaker בקנה מידה. הוא מתמחה בתחומי למידת מכונה, בינה מלאכותית וראייה ממוחשבת, ובעל תואר שני במדעי המחשב מאוניברסיטת דאלאס. בזמנו הפנוי הוא אוהב לטייל ולצלם.

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

מוהן גנדי הוא מהנדס תוכנה בכיר ב-AWS. הוא עובד ב-AWS במשך 10 השנים האחרונות ועבד על שירותי AWS שונים כמו EMR, EFA ו-RDS. נכון לעכשיו, הוא מתמקד בשיפור חוויית SageMaker Inference Experience. בזמנו הפנוי הוא נהנה מטיולים ומרתונים.

• הפצת תוכן ויחסי ציבור מופעל על ידי SEO. קבל הגברה היום.
• PlatoData.Network Vertical Generative Ai. העצים את עצמך. גישה כאן.
• PlatoAiStream. Web3 Intelligence. הידע מוגבר. גישה כאן.
• PlatoESG. פחמן, קלינטק, אנרגיה, סביבה, שמש, ניהול פסולת. גישה כאן.
• PlatoHealth. מודיעין ביוטכנולוגיה וניסויים קליניים. גישה כאן.
• מקור: https://aws.amazon.com/blogs/machine-learning/package-and-deploy-classical-ml-and-llms-easily-with-amazon-sagemaker-part-1-pysdk-improvements/