ארגן את מסע למידת המכונה שלך עם Amazon SageMaker Experiments ו-Amazon SageMaker Pipelines

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

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

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

מדוע חשוב לשמור על הניסויים שלך מאורגנים?

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

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

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

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

היתרונות של ניסויי SageMaker

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

נתחיל קודם עם סקירה כללית של מה שאתה יכול לעשות עם ניסויים:

• ארגן ניסויים - ניסויים מבנים ניסויים עם ישות ברמה העליונה הנקראת an לְנַסוֹת שמכיל קבוצה של ניסויים. כל ניסיון מכיל קבוצה של שלבים הנקראים רכיבי ניסיון. כל רכיב ניסוי הוא שילוב של מערכי נתונים, אלגוריתמים ופרמטרים. אתה יכול לתאר ניסויים בתור התיקיה ברמה העליונה לארגון ההשערות שלך, הניסויים שלך כתיקיות המשנה עבור כל ריצת מבחן קבוצתית, ורכיבי הניסיון שלך כקבצים עבור כל מופע של ריצת מבחן.
• עקוב אחר ניסויים - ניסויים מאפשרים למדעני נתונים לעקוב אחר ניסויים. הוא מציע את האפשרות להקצות אוטומטית משרות SageMaker לניסיון באמצעות תצורות פשוטות ודרך ערכות ה-SDK למעקב.
• השוו והעריכו ניסויים - השילוב של ניסויים עם סטודיו SageMaker של אמזון מקל על הפקת הדמיות נתונים והשוואת ניסויים שונים. אתה יכול גם לגשת לנתוני הניסיון דרך ה- Python SDK כדי ליצור הדמיה משלך באמצעות ספריות התווים המועדפות עליך.

למידע נוסף על ממשקי API ו-SDK של ניסויים, אנו ממליצים על התיעוד הבא: צור ניסוי ו Amazon SageMaker Experiments Python SDK.

אם אתה רוצה לצלול יותר לעומק, אנו ממליצים לבדוק את amazon-sagemaker-examples/sagemaker-experiments מאגר GitHub לדוגמאות נוספות.

אינטגרציה בין צינורות וניסויים

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

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

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

קוד SageMaker Pipelines

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

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

base_job_prefix = "pipeline-experiment-sample"
model_package_group_name = "pipeline-experiment-model-package"

processing_instance_count = ParameterInteger(
  name="ProcessingInstanceCount", default_value=1
)

training_instance_count = ParameterInteger(
  name="TrainingInstanceCount", default_value=1
)

processing_instance_type = ParameterString(
  name="ProcessingInstanceType", default_value="ml.m5.xlarge"
)
training_instance_type = ParameterString(
  name="TrainingInstanceType", default_value="ml.m5.xlarge"
)

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

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

framework_version = "0.23-1"

sklearn_processor = SKLearnProcessor(
    framework_version=framework_version,
    instance_type=processing_instance_type,
    instance_count=processing_instance_count,
    base_job_name="sklearn-ca-housing",
    role=role,
)

process_step = ProcessingStep(
    name="ca-housing-preprocessing",
    processor=sklearn_processor,
    outputs=[
        ProcessingOutput(
            output_name="train",
            source="/opt/ml/processing/train",
            destination=Join(
                on="/",
                values=[
                    "s3://{}".format(bucket),
                    prefix,
                    ExecutionVariables.PIPELINE_EXECUTION_ID,
                    "train",
                ],
            ),
        ),
        ProcessingOutput(
            output_name="validation",
            source="/opt/ml/processing/validation",
            destination=Join(
                on="/",
                values=[
                    "s3://{}".format(bucket),
                    prefix,
                    ExecutionVariables.PIPELINE_EXECUTION_ID,
                    "validation",
                ],
            )
        ),
        ProcessingOutput(
            output_name="test",
            source="/opt/ml/processing/test",
            destination=Join(
                on="/",
                values=[
                    "s3://{}".format(bucket),
                    prefix,
                    ExecutionVariables.PIPELINE_EXECUTION_ID,
                    "test",
                ],
            )
        ),
    ],
    code="california-housing-preprocessing.py",
)

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

model_path = f"s3://{default_bucket}/{base_job_prefix}/ca-housing-experiment-pipeline"

image_uri = sagemaker.image_uris.retrieve(
    framework="xgboost",
    region=region,
    version="1.2-2",
    py_version="py3",
    instance_type=training_instance_type,
)

xgb_train = Estimator(
    image_uri=image_uri,
    instance_type=training_instance_type,
    instance_count=training_instance_count,
    output_path=model_path,
    base_job_name=f"{base_job_prefix}/ca-housing-train",
    sagemaker_session=sagemaker_session,
    role=role,
)

xgb_train.set_hyperparameters(
    eval_metric="rmse",
    objective="reg:squarederror",  # Define the object metric for the training job
    num_round=50,
    max_depth=5,
    eta=0.2,
    gamma=4,
    min_child_weight=6,
    subsample=0.7
)

אנו מבצעים כוונון היפרפרמטר של המודלים שאנו יוצרים באמצעות a ContinuousParameter טווח עבור lambda. בחירת מדד אחד להיות המדד האובייקטיבי אומר למכוון (המופע שמריץ את עבודות כוונון ההיפרפרמטרים) שתעריך את עבודת ההדרכה על סמך המדד הספציפי הזה. הטיונר מחזיר את השילוב הטוב ביותר בהתבסס על הערך הטוב ביותר עבור מדד אובייקטיבי זה, כלומר השילוב הטוב ביותר שממזער את שגיאת ה-Root Mean Square (RMSE) הטובה ביותר.

objective_metric_name = "validation:rmse"

hyperparameter_ranges = {
    "lambda": ContinuousParameter(0.01, 10, scaling_type="Logarithmic")
}

tuner = HyperparameterTuner(estimator,
                            objective_metric_name,
                            hyperparameter_ranges,
                            objective_type=objective_type,
                            strategy="Bayesian",
                            max_jobs=10,
                            max_parallel_jobs=3)

tune_step = TuningStep(
    name="HPTuning",
    tuner=tuner_log,
    inputs={
        "train": TrainingInput(
            s3_data=process_step.properties.ProcessingOutputConfig.Outputs[
                "train"
            ].S3Output.S3Uri,
            content_type="text/csv",
        ),
        "validation": TrainingInput(
            s3_data=process_step.properties.ProcessingOutputConfig.Outputs[
                "validation"
            ].S3Output.S3Uri,
            content_type="text/csv",
        ),
    } 
)

שלב הכוונון מפעיל ניסויים מרובים במטרה לקבוע את הדגם הטוב ביותר מבין טווחי הפרמטרים שנבדקו. עם השיטה get_top_model_s3_uri, אנו מדרגים את 50 הגרסאות המובילות בביצועים של דגם artifact S3 URI ומחלצים רק את הגרסה בעלת הביצועים הטובים ביותר (אנו מציינים k=0 לטובה) כדי ליצור מודל של SageMaker.

model_bucket_key = f"{default_bucket}/{base_job_prefix}/ca-housing-experiment-pipeline"
model_candidate = Model(
    image_uri=image_uri,
    model_data=tune_step.get_top_model_s3_uri(top_k=0, s3_bucket=model_bucket_key),
    sagemaker_session=sagemaker_session,
    role=role,
    predictor_cls=XGBoostPredictor,
)

create_model_step = CreateModelStep(
    name="CreateTopModel",
    model=model_candidate,
    inputs=sagemaker.inputs.CreateModelInput(instance_type="ml.m4.large"),
)

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

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

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

#Pipeline experiment config
ca_housing_experiment_config = PipelineExperimentConfig(
    experiment_name,
    Join(
        on="-",
        values=[
            "pipeline-execution",
            ExecutionVariables.PIPELINE_EXECUTION_ID
        ],
    )
)

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

pipeline_name = f"CAHousingExperimentsPipeline"

pipeline = Pipeline(
    name=pipeline_name,
    pipeline_experiment_config=ca_housing_experiment_config,
    parameters=[
        processing_instance_count,
        processing_instance_type,
        training_instance_count,
        training_instance_type
    ],
    steps=[process_step,tune_step,create_model_step],
)

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

pipeline.upsert(role_arn=sagemaker.get_execution_role())
execution = pipeline.start()

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

# SM Pipeline injects the Execution ID into trial component names
execution_id = execution.describe()['PipelineExecutionArn'].split('/')[-1]
source_arn_filter = Filter(
    name="TrialComponentName", operator=Operator.CONTAINS, value=execution_id
)

source_type_filter = Filter(
    name="Source.SourceType", operator=Operator.EQUALS, value="SageMakerTrainingJob"
)

search_expression = SearchExpression(
    filters=[source_arn_filter, source_type_filter]
)

trial_component_analytics = ExperimentAnalytics(
    sagemaker_session=sagemaker_session,
    experiment_name=experiment_name,
    search_expression=search_expression.to_boto()
)

analytic_table = trial_component_analytics.dataframe()
analytic_table.head()

השווה את המדדים עבור כל רכיב ניסיון

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

חקור את מדדי ההדרכה וההערכה ב-Studio

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

1. בחרו ניסויים וניסויים מ משאבי SageMaker סמל בסרגל הצד השמאלי.
2. בחר את הניסוי שלך כדי לפתוח אותו.
3. בחר (לחץ באמצעות לחצן העכבר הימני) בניסיון המעניין.
4. בחרו פתח ברשימת רכיבי הניסיון.
5. חדשות ועדכונים משמרת כדי לבחור את מרכיבי הניסיון המייצגים את עבודות ההדרכה.
6. בחרו הוסף תרשים.
7. בחרו תרשים חדש והתאם אישית את המדדים שנאספו שאתה רוצה לנתח. עבור מקרה השימוש שלנו, בחר את האפשרויות הבאות:
   1. בעד סוג מידעבחר סטטיסטיקות סיכום.
   2. בעד סוג תרשיםבחר גרף פיזור.
   3. בעד ציר X, בחר lambda.
   4. בעד ציר Y, בחר validation:rmse_last.

התרשים החדש מופיע בתחתית החלון, עם התווית '8'.

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

אנליטיקה עם ניסויי SageMaker

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

analytic_table.plot.scatter("lambda", "validation:rmse - Last", grid=True)

סיכום

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

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

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

כשלב הבא, אתה יכול להשתמש בשלושת התכונות הללו של SageMaker - Studio, Experiments ו-Pipelines - עבור פרויקט ה-ML הבא שלך.

הצעות קריאה מומלצות

על המחברים

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

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

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

ולרי סונטאקית' הוא ארכיטקט פתרונות עבור AWS, עובד בתעשיית המשחקים ועם שותפים הפורסים פתרונות AI. היא שואפת לבנות את הקריירה שלה סביב Computer Vision. בזמנה הפנוי, ולרי מבלה אותו כדי לטייל, לגלות מקומות אוכל חדשים ולשנות את פנים הבית שלה.