לוגו זפירנט

הפחת את העלות וזמן הפיתוח עם מצב מקומי של Amazon SageMaker Pipelines

תאריך:

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

סקירה כללית של מחזור החיים של ML

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

  1. ניקוי והכנת נתונים (הנדסת תכונות)
  2. אימון וכוונון מודל
  3. הערכת מודל
  4. פריסת מודל (או שינוי אצווה)

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

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

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

צינורות SageMaker

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

SageMaker Pipelines מביאה ל-ML שיטות אינטגרציה ופריסה מתמשכת (CI/CD), כגון שמירה על שוויון בין סביבות פיתוח וייצור, בקרת גרסאות, בדיקות לפי דרישה ואוטומציה מקצה לקצה, מה שעוזר לך להרחיב את ה-ML לאורך אִרגוּן. מתרגלי DevOps יודעים שכמה מהיתרונות העיקריים של שימוש בטכניקות CI/CD כוללים עלייה בפריון באמצעות רכיבים הניתנים לשימוש חוזר ועלייה באיכות באמצעות בדיקות אוטומטיות, מה שמוביל להחזר ROI מהיר יותר עבור היעדים העסקיים שלך. הטבות אלה זמינות כעת למתרגלי MLOps באמצעות SageMaker Pipelines כדי להפוך את ההדרכה, הבדיקות והפריסה של מודלים של ML לאוטומטיים. עם מצב מקומי, אתה יכול כעת לבצע איטרציה הרבה יותר מהר תוך פיתוח סקריפטים לשימוש בצינור. שים לב שלא ניתן להציג או להפעיל מופעי צינור מקומיים בתוך ה-Studio IDE; עם זאת, אפשרויות צפייה נוספות עבור צינורות מקומיים יהיו זמינות בקרוב.

ה-SDK של SageMaker מספק מטרה כללית תצורת מצב מקומי המאפשר למפתחים להפעיל ולבדוק מעבדים ואומדנים נתמכים בסביבה המקומית שלהם. אתה יכול להשתמש באימון במצב מקומי עם מספר תמונות מסגרת הנתמכות ב-AWS (TensorFlow, MXNet, Chainer, PyTorch ו-Scikit-Learn) כמו גם תמונות שאתה מספק בעצמך.

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

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

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

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

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

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

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

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

התרשים הבא ממחיש את הצינור שלנו.

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

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

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

בנה את הצינור שלך

בדוגמה של מחברת זו, אנו משתמשים מצב סקריפט של SageMaker עבור רוב תהליכי ה-ML, מה שאומר שאנו מספקים את קוד Python בפועל (סקריפטים) לביצוע הפעילות ולהעביר הפניה לקוד זה. מצב סקריפט מספק גמישות רבה לשלוט בהתנהגות בתוך עיבוד SageMaker על ידי כך שהוא מאפשר לך להתאים אישית את הקוד שלך תוך ניצול של מכולות מובנות מראש של SageMaker כמו XGBoost או Scikit-Learn. הקוד המותאם אישית נכתב לקובץ סקריפט של Python באמצעות תאים שמתחילים בפקודת הקסם %%writefile, כמו הדברים הבאים:

%%writefile code/evaluation.py

המאפשר העיקרי של מצב מקומי הוא LocalPipelineSession אובייקט, אשר מופק מ- Python SDK. מקטעי הקוד הבאים מראים כיצד ליצור צינור של SageMaker במצב מקומי. למרות שאתה יכול להגדיר נתיב נתונים מקומי עבור רבים משלבי הצינור המקומי, Amazon S3 הוא מיקום ברירת המחדל לאחסון פלט הנתונים על ידי השינוי. החדש LocalPipelineSession האובייקט מועבר ל- Python SDK ברבות מקריאות זרימת העבודה של SageMaker API המתוארות בפוסט זה. שים לב שאתה יכול להשתמש ב- local_pipeline_session משתנה כדי לאחזר הפניות לדלי ברירת המחדל של S3 ולשם האזור הנוכחי.

from sagemaker.workflow.pipeline_context import LocalPipelineSession

# Create a `LocalPipelineSession` object so that each 
# pipeline step will run locally
# To run this pipeline in the cloud, you must change 
# the `LocalPipelineSession()` to `PipelineSession()`
local_pipeline_session = LocalPipelineSession()
region = local_pipeline_session.boto_region_name

default_bucket = local_pipeline_session.default_bucket()
prefix = "sagemaker-pipelines-local-mode-example"

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

mse_threshold = ParameterFloat(name="MseThreshold", default_value=7.0)

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

from sagemaker.sklearn.processing import SKLearnProcessor

framework_version = "1.0-1"

sklearn_processor = SKLearnProcessor(
    framework_version=framework_version,
    instance_type=instance_type,
    instance_count=processing_instance_count,
    base_job_name="sklearn-abalone-process",
    role=role,
    sagemaker_session=local_pipeline_session,
)

לאחר מכן, אנו יוצרים את שלב הצינור האמיתי הראשון שלנו, א ProcessingStep אובייקט, כפי שיובאו מה-SDK של SageMaker. ארגומנטי המעבד מוחזרים מקריאה ל- SKLearnProcessor שיטת run() . שלב זרימת עבודה זה משולב עם שלבים אחרים לקראת סוף המחברת כדי לציין את סדר הפעולה בתוך הצינור.

from sagemaker.processing import ProcessingInput, ProcessingOutput
from sagemaker.workflow.steps import ProcessingStep

processor_args = sklearn_processor.run(
    inputs=[
        ProcessingInput(source=input_data, destination="/opt/ml/processing/input"),
    ],
    outputs=[
        ProcessingOutput(output_name="train", source="/opt/ml/processing/train"),
        ProcessingOutput(output_name="validation", source="/opt/ml/processing/validation"),
        ProcessingOutput(output_name="test", source="/opt/ml/processing/test"),
    ],
    code="code/preprocessing.py",
)

step_process = ProcessingStep(name="AbaloneProcess", step_args=processor_args)

לאחר מכן, אנו מספקים קוד לקביעת שלב הדרכה על ידי מופע תחילה של מעריך סטנדרטי באמצעות SageMaker SDK. אנחנו עוברים אותו דבר local_pipeline_session משתנה לאומד, בשם xgb_train, בתור sagemaker_session טַעֲנָה. מכיוון שאנו רוצים לאמן מודל XGBoost, עלינו ליצור URI תמונה חוקי על ידי ציון הפרמטרים הבאים, כולל המסגרת ומספר פרמטרים של גרסה:

from sagemaker.estimator import Estimator
from sagemaker.inputs import TrainingInput

model_path = f"s3://{default_bucket}/{prefix}/model"
image_uri = sagemaker.image_uris.retrieve(
    framework="xgboost",
    region=region,
    version="1.5-1",
    py_version="py3",
    instance_type=instance_type,
)

xgb_train = Estimator(
    image_uri=image_uri,
    entry_point="code/abalone.py",
    instance_type=instance_type,
    instance_count=training_instance_count,
    output_path=model_path,
    role=role,
    sagemaker_session=local_pipeline_session,
)

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

from sagemaker.workflow.steps import TrainingStep

step_train = TrainingStep(name="AbaloneTrain", step_args=train_args)

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

from sagemaker.processing import ScriptProcessor

script_eval = ScriptProcessor(
    image_uri=image_uri,
    command=["python3"],
    instance_type=instance_type,
    instance_count=processing_instance_count,
    base_job_name="script-abalone-eval",
    role=role,
    sagemaker_session=local_pipeline_session,
)

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

from sagemaker.model import Model

model = Model(
    image_uri=image_uri,
    model_data=step_train.properties.ModelArtifacts.S3ModelArtifacts,
    source_dir="code",
    entry_point="inference.py",
    role=role,
    sagemaker_session=local_pipeline_session,
)

from sagemaker.workflow.model_step import ModelStep

step_create_model = ModelStep(name="AbaloneCreateModel", 
    step_args=model.create(instance_type=instance_type)
)

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

from sagemaker.transformer import Transformer

transformer = Transformer(
    model_name=step_create_model.properties.ModelName,
    instance_type=instance_type,
    instance_count=transform_instance_count,
    output_path=f"s3://{default_bucket}/{prefix}/transform",
    sagemaker_session=local_pipeline_session,
)

from sagemaker.workflow.steps import TransformStep

transform_args = transformer.transform(transform_data, content_type="text/csv")

step_transform = TransformStep(name="AbaloneTransform", step_args=transform_args)

לבסוף, ברצוננו להוסיף תנאי ענף לזרימת העבודה כך שנפעיל טרנספורמציה אצווה רק אם התוצאות של הערכת מודל עומדות בקריטריונים שלנו. נוכל לציין תנאי זה על ידי הוספת א ConditionStep עם סוג תנאי מסוים, כמו ConditionLessThanOrEqualTo. לאחר מכן, אנו מונה את השלבים עבור שני הענפים, ובעצם מגדירים את הענפים אם/אחר או נכון/לא נכון של הצינור. ה-if_steps שסופקו ב- ConditionStep (step_create_model, step_transform) מופעלים בכל פעם שהתנאי מעריך True.

from sagemaker.workflow.conditions import ConditionLessThanOrEqualTo
from sagemaker.workflow.condition_step import ConditionStep
from sagemaker.workflow.functions import JsonGet

cond_lte = ConditionLessThanOrEqualTo(
    left=JsonGet(
        step_name=step_eval.name,
        property_file=evaluation_report,
        json_path="regression_metrics.mse.value",),
    right=mse_threshold,
)

step_cond = ConditionStep(
    name="AbaloneMSECond",
    conditions=[cond_lte],
    if_steps=[step_create_model, step_transform],
    else_steps=[step_fail],
)

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

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

from sagemaker.workflow.pipeline import Pipeline

pipeline_name = f"LocalModelPipeline"
pipeline = Pipeline(
    name=pipeline_name,
    parameters=[
        input_data,
        mse_threshold,
    ],
    steps=[step_process, step_train, step_eval, step_cond],
    sagemaker_session=local_pipeline_session,
)

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

pipeline.upsert(role_arn=role)
execution = pipeline.start()

אתה אמור לראות הודעה בתחתית פלט התא הדומה להודעה הבאה:

Pipeline execution d8c3e172-089e-4e7a-ad6d-6d76caf987b7 SUCCEEDED

חזור למשאבים מנוהלים

לאחר שאישרנו שהצינור פועל ללא שגיאות ואנו מרוצים מהזרימה והצורה של הצינור, נוכל ליצור מחדש את הצינור אך עם משאבים מנוהלים של SageMaker ולהפעיל אותו מחדש. השינוי היחיד שנדרש הוא להשתמש ב- PipelineSession חפץ במקום LocalPipelineSession:

החל מ- sagemaker.workflow.pipeline_context ייבוא ​​LocalPipelineSession
from sagemaker.workflow.pipeline_context import PipelineSession

local_pipeline_session = LocalPipelineSession()
pipeline_session = PipelineSession()

זה מודיע לשירות להפעיל כל שלב המתייחס לאובייקט הפעלה זה במשאבים מנוהלים של SageMaker. בהתחשב בשינוי הקטן, אנו מדגים רק את שינויי הקוד הנדרשים בתא הקוד הבא, אך יהיה צורך ליישם את אותו שינוי בכל תא באמצעות local_pipeline_session לְהִתְנַגֵד. השינויים, עם זאת, זהים בכל התאים מכיוון שאנו מחליפים רק את local_pipeline_session חפץ עם pipeline_session אובייקט.

from sagemaker.sklearn.processing import SKLearnProcessor

framework_version = "1.0-1"

sklearn_processor = SKLearnProcessor(
    framework_version=framework_version,
    instance_type=instance_type,
    instance_count=processing_instance_count,
    base_job_name="sklearn-abalone-process",
    role=role,
    sagemaker_session=pipeline_session,  # non-local session
)

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

from sagemaker.workflow.pipeline import Pipeline

pipeline_name = f"LocalModelPipeline"
pipeline = Pipeline(
    name=pipeline_name,
    parameters=[
        input_data,
        mse_threshold,
    ],
    steps=[step_process, step_train, step_eval, step_cond],
    sagemaker_session=pipeline_session, # non-local session
)

pipeline.upsert(role_arn=role)
execution = pipeline.start()

לנקות את

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

# delete models 
sm_client = boto3.client("sagemaker")
model_prefix="AbaloneCreateModel"
delete_models(sm_client, model_prefix)

# delete managed pipeline
pipeline_to_delete = 'SM-Managed-Pipeline'
delete_sagemaker_pipeline(sm_client, pipeline_to_delete)

סיכום

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

כדי ללמוד עוד, בקר צינורות SageMaker של אמזון or השתמש ב-SageMaker Pipelines כדי להפעיל את העבודות שלך באופן מקומי.


על המחברים

פול הארגיס מיקד את מאמציו בלמידת מכונה במספר חברות, כולל AWS, Amazon ו- Hortonworks. הוא נהנה לבנות פתרונות טכנולוגיים וללמד אנשים כיצד להפיק את המרב מהם. לפני תפקידו ב-AWS, הוא היה הארכיטקט הראשי של אמזון יצוא והרחבות, ועזר ל-amazon.com לשפר את החוויה עבור קונים בינלאומיים. פול אוהב לעזור ללקוחות להרחיב את יוזמות למידת המכונה שלהם כדי לפתור בעיות בעולם האמיתי.

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

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

ספוט_ימג

המודיעין האחרון

ספוט_ימג