עקוב אחר ניסויי ה-ML שלך מקצה לקצה עם בקרת גרסאות נתונים וניסויי אמזון SageMaker

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

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

SageMaker ניסויים

SageMaker Experiments הוא שירות AWS למעקב אחר ניסויי למידת מכונה (ML). ה SageMaker Experiments Python SDK הוא ממשק ברמה גבוהה לשירות זה שעוזר לך לעקוב אחר מידע על הניסוי באמצעות Python.

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

כאשר דנים בניסויי SageMaker, אנו מתייחסים למושגים הבאים:

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

בקרת גרסאות נתונים

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

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

ל-DVC יש את התכונות הבאות:

• DVC הוא א חופשי, קוד פתוח שורת הפקודה כלי.
• DVC עובד על גבי מאגרי Git ויש לו ממשק שורת פקודה וזרימה דומים כמו Git. DVC יכול לעבוד גם עצמאי, אבל בלי גרסאות יכולות.
• ניהול גרסאות נתונים מתאפשר על ידי החלפת קבצים גדולים, ספריות נתונים, דגמי ML וכן הלאה בקטנים metafiles (קל לטפל ב-Git). מצייני מיקום אלה מצביעים על הנתונים המקוריים, אשר מנותקים מניהול קוד המקור.
• אתה יכול להשתמש באחסון מקומי או בענן כדי לאחסן את נתוני הפרויקט בנפרד מבסיס הקוד שלו. כך יכולים מדעני נתונים להעביר מערכי נתונים גדולים או לחלוק מודל מאומן GPU עם אחרים.
• DVC הופך פרויקטים של מדעי הנתונים לניתנים לשחזור על ידי יצירת קל משקל צינורות באמצעות גרפי תלות מרומזים, ועל ידי קודידציה של הנתונים והחפצים המעורבים.
• DVC הוא אגנסטי לפלטפורמה. הוא פועל על כל מערכות ההפעלה העיקריות (Linux, macOS ו-Windows), ועובד ללא תלות בשפות התכנות (Python, R, Julia, סקריפטים של מעטפת וכן הלאה) או ספריות ML (Keras, TensorFlow, PyTorch, Scipy וכו' יותר) בשימוש בפרויקט.
• DVC מהיר להתקין ואינו דורש תשתית מיוחדת, ואינו תלוי בממשקי API או שירותים חיצוניים. זהו כלי CLI עצמאי.

SageMaker Experiments ודוגמת DVC

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

התרשים הבא ממחיש את ארכיטקטורת הפתרון וזרימת העבודה.

בנה תמונת סטודיו מותאמת אישית כאשר DVC כבר מותקן

בחודש זה מאגר GitHub, אנו מסבירים כיצד ליצור תמונה מותאמת אישית עבור Studio שכבר מותקן בה DVC. היתרון ביצירת תמונה והפיכתה לזמינה לכל משתמשי הסטודיו הוא בכך שהיא יוצרת סביבה עקבית עבור משתמשי הסטודיו, שאותה יוכלו להפעיל גם באופן מקומי. למרות שהמדגם מבוסס על AWS Cloud9, אתה יכול גם לבנות את המכולה במחשב המקומי שלך כל עוד יש לך Docker מותקן ופועל. מדגם זה מבוסס על הדברים הבאים דוקרפיל ו environment.yml. תמונת ה-Docker המתקבלת מאוחסנת ב מרשם מיכל אלסטי של אמזון (Amazon EMR) בחשבון AWS שלך. ראה את הקוד הבא:

# Login to ECR
aws --region ${REGION} ecr get-login-password | docker login --username AWS --password-stdin ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/smstudio-custom

# Create the ECR repository
aws --region ${REGION} ecr create-repository --repository-name smstudio-custom

# Build the image - it might take a few minutes to complete this step
docker build . -t ${IMAGE_NAME} -t ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/smstudio-custom:${IMAGE_NAME}

# Push the image to ECR
docker push ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/smstudio-custom:${IMAGE_NAME}

עכשיו אתה יכול ליצור דומיין חדש של Studio or לעדכן דומיין קיים של Studio שיש לו גישה לתמונת Docker החדשה שנוצרה.

אנו משתמשים ערכת פיתוח ענן AWS (AWS CDK) כדי ליצור את המשאבים הבאים באמצעות AWS CloudFormation:

• תפקיד ביצוע של SageMaker עם ההרשאות הנכונות לדומיין הסטודיו החדש או הקיים שלך
• תמונת SageMaker וגרסת תמונת SageMaker מתמונת Docker conda-env-dvc-kernel שיצרנו קודם לכן
• An AppImageConfig שמציין כיצד יש להגדיר את שער הליבה
• משתמש סטודיו (data-scientist-dvc) עם תפקיד הביצוע הנכון של SageMaker ותמונת הסטודיו המותאמת הזמינה עבורו

להנחיות מפורטות, עיין ב שייך תמונה מותאמת אישית ל-SageMaker Studio.

תפעיל את המעבדה

כדי להפעיל את המעבדה, בצע את השלבים הבאים:

1. בדומיין Studio, הפעל את Studio עבור data-scientist-dvc המשתמש.
2. בחר בסמל Git ולאחר מכן בחר שיבוט מאגר.
   
3. הזן את כתובת האתר של המאגר (https://github.com/aws-samples/amazon-sagemaker-experiments-dvc-demo) ובחר שיבוט.
4. בדפדפן הקבצים, בחר את amazon-sagemaker-experiments-dvc-demo מאגר.
5. פתח את dvc_sagemaker_script_mode.ipynb מחברת.
6. בעד תמונה מותאמת אישית, בחר את התמונה conda-env-dvc-kernel.
7. בחרו בחר.
   

הגדר את DVC לניהול גרסאות נתונים

אנו יוצרים תת-ספרייה שבה אנו מכינים את הנתונים: sagemaker-dvc-sample. בתוך ספריית משנה זו, אנו מאתחלים מאגר Git חדש ומגדירים את השלט למאגר שאנו יוצרים בו AWS CodeCommit. המטרה היא לקבל גרסאות של תצורות DVC וקבצים למעקב אחר נתונים במאגר זה. עם זאת, Git מציעה יכולות מקוריות לניהול תת-פרויקטים באמצעות, למשל, תת-מודולי git ותתי-עצים של git, ואתה יכול להרחיב את המדגם הזה לשימוש בכל אחד מהכלים שהוזכרו לעיל המתאימים ביותר לזרימת העבודה שלך.

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

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

מעבד ואימון עם DVC ו- SageMaker

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

הגדר ניסוי של SageMaker

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

אנחנו יוצרים ניסוי בשם DEMO-sagemaker-experiments-dvc עם שני ניסויים, dvc-trial-single-file ו dvc-trial-multi-files, כל אחד מייצג גרסה אחרת של מערך הנתונים.

בואו ניצור את DEMO-sagemaker-experiments-dvc לְנַסוֹת:

from smexperiments.experiment import Experiment
from smexperiments.trial import Trial
from smexperiments.trial_component import TrialComponent
from smexperiments.tracker import Tracker

experiment_name = 'DEMO-sagemaker-experiments-dvc'

# create the experiment if it doesn't exist
try:
    my_experiment = Experiment.load(experiment_name=experiment_name)
    print("existing experiment loaded")
except Exception as ex:
    if "ResourceNotFound" in str(ex):
        my_experiment = Experiment.create(
            experiment_name = experiment_name,
            description = "How to integrate DVC"
        )
        print("new experiment created")
    else:
        print(f"Unexpected {ex}=, {type(ex)}")
        print("Dont go forward!")
        raise

מבחן 1: צור קבצים בודדים להדרכה ואימות

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

ראשית, אנו יוצרים את dvc-trial-single-file ניסיון והוסיפו אותו ל- DEMO-sagemaker-experiments-dvc לְנַסוֹת. על ידי כך, אנו שומרים על כל מרכיבי הניסוי הקשורים למבחן זה מאורגנים בצורה משמעותית.

first_trial_name = "dvc-trial-single-file"

try:
    my_first_trial = Trial.load(trial_name=first_trial_name)
    print("existing trial loaded")
except Exception as ex:
    if "ResourceNotFound" in str(ex):
        my_first_trial = Trial.create(
            experiment_name=experiment_name,
            trial_name=first_trial_name,
        )
        print("new trial created")
    else:
        print(f"Unexpected {ex}=, {type(ex)}")
        print("Dont go forward!")
        raise

השתמש ב-DVC בעבודת עיבוד של SageMaker כדי ליצור את גרסת הקובץ הבודד

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

לבסוף, אנו מאחדים את יכולות המעקב של DVC עם יכולות המעקב של SageMaker בעת הפעלת עבודות עיבוד באמצעות SageMaker Experiments.

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

• DVC_REPO_URL
• DVC_BRANCH
• USER
• data_commit_hash
• train_test_split_ratio

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

סקריפט העיבוד המקדים המלא של Python זמין ב- GitHub ריפו.

with Tracker.load() as tracker:
    tracker.log_parameters({"data_commit_hash": commit_hash})
    for file_type in file_types:
        path = dvc.api.get_url(
            f"{data_path}/{file_type}/california_{file_type}.csv",
            repo=dvc_repo_url,
            rev=dvc_branch
        )
        tracker.log_output(name=f"california_{file_type}",value=path)

SageMaker נותן לנו את האפשרות להריץ את סקריפט העיבוד שלנו על תמונות קונטיינר המנוהלות על ידי AWS המותאמות לרוץ על תשתית AWS. אם הסקריפט שלנו דורש תלות נוספות, נוכל לספק א requirements.txt קוֹבֶץ. כאשר אנו מתחילים את עבודת העיבוד, SageMaker משתמש pip-install להתקין את כל הספריות שאנו צריכים (לדוגמה, ספריות הקשורות ל-DVC). אם אתה צריך שליטה הדוקה יותר על כל הספריות המותקנות על הקונטיינרים, אתה יכול להביא קונטיינר משלך ב- SageMaker, למשל עבור תהליך ומתאמן.

יש לנו כעת את כל המרכיבים להפעלת עבודת העיבוד של SageMaker שלנו:

• סקריפט עיבוד שיכול לעבד מספר ארגומנטים (--train-test-split-ratio) ושני משתנים סביבתיים (DVC_REPO_URL ו DVC_BRANCH)
• A requiremets.txt פילה
• מאגר Git (ב-CodeCommit)
• ניסוי וניסוי של SageMaker

from sagemaker.processing import FrameworkProcessor, ProcessingInput
from sagemaker.sklearn.estimator import SKLearn

dvc_repo_url = "codecommit::{}://sagemaker-dvc-sample".format(region)
dvc_branch = my_first_trial.trial_name

script_processor = FrameworkProcessor(
    estimator_cls=SKLearn,
    framework_version='0.23-1',
    instance_count=1,
    instance_type='ml.m5.xlarge',
    env={
        "DVC_REPO_URL": dvc_repo_url,
        "DVC_BRANCH": dvc_branch,
        "USER": "sagemaker"
    },
    role=role
)

experiment_config={
    "ExperimentName": my_experiment.experiment_name,
    "TrialName": my_first_trial.trial_name
}

לאחר מכן אנו מפעילים את עבודת העיבוד עם preprocessing-experiment.py תַסרִיט, experiment_config, dvc_repo_url, ו dvc_branch הגדרנו קודם.

%%time

script_processor.run(
    code='./source_dir/preprocessing-experiment.py',
    dependencies=['./source_dir/requirements.txt'],
    inputs=[ProcessingInput(source=s3_data_path, destination="/opt/ml/processing/input")],
    experiment_config=experiment_config,
    arguments=["--train-test-split-ratio", "0.2"]
)

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

צילום המסך הבא מראה היכן אתה יכול למצוא את המידע המאוחסן בסטודיו. שימו לב לערכים עבור dvc-trial-single-file in DVC_BRANCH, DVC_REPO_URL, ו data_commit_hash על פרמטרים TAB.

שימו לב גם לפרטי הקלט והפלט ב- חפץ TAB.

צור אומדן והתאם למודל גרסת נתוני קובץ בודד

כדי להשתמש באינטגרציה של DVC בתוך עבודת הכשרה של SageMaker, אנו עוברים א dvc_repo_url ו dvc_branch כמשתנים סביבתיים בעת יצירת האובייקט Estimator.

אנחנו מתאמנים על dvc-trial-single-file סניף ראשון.

בעת שליפת נתונים עם DVC, אנו משתמשים במבנה הנתונים הבא:

dataset
    |-- train
    |   |-- california_train.csv
    |-- test
    |   |-- california_test.csv
    |-- validation
    |   |-- california_validation.csv

כעת אנו יוצרים הערכה של Scikit-learn באמצעות ה SageMaker Python SDK. זה מאפשר לנו לציין את הדברים הבאים:

• הנתיב לקובץ המקור של Python, אותו יש להפעיל כנקודת הכניסה לאימון.
• תפקיד IAM השולט בהרשאות לגישה לנתוני Amazon S3 ו- CodeCommit והפעלת פונקציות SageMaker.
• רשימה של מילונים המגדירים את המדדים המשמשים להערכת משרות ההכשרה.
• מספר וסוג מקרי האימון. אנו משתמשים במופע אחד של ml.m5.large.
• היפרפרמטרים המשמשים לאימון.
• משתני סביבה לשימוש במהלך עבודת ההדרכה. אנו משתמשים DVC_REPO_URL, DVC_BRANCH, ו USER.

metric_definitions = [{'Name': 'median-AE', 'Regex': "AE-at-50th-percentile: ([0-9.]+).*$"}]

hyperparameters={ 
        "learning_rate" : 1,
        "depth": 6
    }
estimator = SKLearn(
    entry_point='train.py',
    source_dir='source_dir',
    role=role,
    metric_definitions=metric_definitions,
    hyperparameters=hyperparameters,
    instance_count=1,
    instance_type='ml.m5.large',
    framework_version='0.23-1',
    base_job_name='training-with-dvc-data',
    environment={
        "DVC_REPO_URL": dvc_repo_url,
        "DVC_BRANCH": dvc_branch,
        "USER": "sagemaker"
    }
)

experiment_config={
    "ExperimentName": my_experiment.experiment_name,
    "TrialName": my_first_trial.trial_name
}

אנו קוראים לשיטת ההתאמה של ה-Estimator עם ה-experiment_config שהגדרנו קודם כדי להתחיל את האימון.

%%time
estimator.fit(experiment_config=experiment_config)

עבודת ההדרכה נמשכת כ-5 דקות. היומנים מציגים את השורות הללו, המציינים את הקבצים שנשלפו על ידי DVC:

Running dvc pull command
A       train/california_train.csv
A       test/california_test.csv
A       validation/california_validation.csv
3 files added and 3 files fetched
Starting the training.
Found train files: ['/opt/ml/input/data/dataset/train/california_train.csv']
Found validation files: ['/opt/ml/input/data/dataset/train/california_train.csv']

מבחן 2: צור מספר קבצים להדרכה ואימות

אנחנו יוצרים חדש dvc-trial-multi-files ניסיון ולהוסיף אותו לזרם DEMO-sagemaker-experiments-dvc לְנַסוֹת.

second_trial_name = "dvc-trial-multi-files"
try:
    my_second_trial = Trial.load(trial_name=second_trial_name)
    print("existing trial loaded")
except Exception as ex:
    if "ResourceNotFound" in str(ex):
        my_second_trial = Trial.create(
            experiment_name=experiment_name,
            trial_name=second_trial_name,
        )
        print("new trial created")
    else:
        print(f"Unexpected {ex}=, {type(ex)}")
        print("Dont go forward!")
        raise

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

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

%%time

script_processor.run(
    code='./source_dir/preprocessing-experiment-multifiles.py',
    dependencies=['./source_dir/requirements.txt'],
    inputs=[ProcessingInput(source=s3_data_path, destination="/opt/ml/processing/input")],
    experiment_config=experiment_config,
    arguments=["--train-test-split-ratio", "0.1"]
)

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

צילומי המסך הבאים מראים היכן תוכל למצוא את המידע המאוחסן בתוך SageMaker Experiments ב- רכיבי ניסיון קטע בתוך ממשק המשתמש של Studio. שימו לב לערכים עבור dvc-trial-multi-files in DVC_BRANCH, DVC_REPO_URL, ו data_commit_hash על פרמטרים TAB.

אתה יכול גם לסקור את פרטי הקלט והפלט ב- חפץ TAB.

כעת אנו מתאמנים על dvc-trial-multi-files ענף. בעת שליפת נתונים עם DVC, אנו משתמשים במבנה הנתונים הבא:

dataset
    |-- train
    |   |-- california_train_1.csv
    |   |-- california_train_2.csv
    |   |-- california_train_3.csv
    |   |-- california_train_4.csv
    |   |-- california_train_5.csv
    |-- test
    |   |-- california_test.csv
    |-- validation
    |   |-- california_validation_1.csv
    |   |-- california_validation_2.csv
    |   |-- california_validation_3.csv

בדומה למה שעשינו בעבר, אנו יוצרים מעריך Scikit-learn חדש עם שם הניסיון dvc-trial-multi-files ולהתחיל את עבודת ההדרכה.

%%time

estimator.fit(experiment_config=experiment_config)

עבודת ההדרכה נמשכת כ-5 דקות. בפלט יומני עבודות ההדרכה למחברת, אתה יכול לראות את השורות האלה, המציינות את הקבצים שנשלפו על ידי DVC:

Running dvc pull command
A       validation/california_validation_2.csv
A       validation/california_validation_1.csv
A       validation/california_validation_3.csv
A       train/california_train_4.csv
A       train/california_train_5.csv
A       train/california_train_2.csv
A       train/california_train_3.csv
A       train/california_train_1.csv
A       test/california_test.csv
9 files added and 9 files fetched
Starting the training.
Found train files: ['/opt/ml/input/data/dataset/train/california_train_2.csv', '/opt/ml/input/data/dataset/train/california_train_5.csv', '/opt/ml/input/data/dataset/train/california_train_4.csv', '/opt/ml/input/data/dataset/train/california_train_1.csv', '/opt/ml/input/data/dataset/train/california_train_3.csv']
Found validation files: ['/opt/ml/input/data/dataset/validation/california_validation_2.csv', '/opt/ml/input/data/dataset/validation/california_validation_1.csv', '/opt/ml/input/data/dataset/validation/california_validation_3.csv']

ארח את הדגם שלך ב- SageMaker

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

from sagemaker.serializers import CSVSerializer

predictor = estimator.deploy(1, "ml.t2.medium", serializer=CSVSerializer())

ראשית, אנו מקבלים את מערך הבדיקה העדכני ביותר באופן מקומי במחברת הפיתוח ב-Studio. למטרה זו, אנו יכולים להשתמש dvc.api.read() כדי לטעון את הנתונים הגולמיים שנשמרו באמזון S3 על ידי עבודת העיבוד של SageMaker.

import io
import dvc.api

raw = dvc.api.read(
    "dataset/test/california_test.csv",
    repo=dvc_repo_url,
    rev=dvc_branch
)

לאחר מכן אנו מכינים את הנתונים באמצעות Pandas, טוענים קובץ CSV לניסיון ומתקשרים predictor.predict להפעיל את נקודת הקצה של SageMaker שנוצרה קודם לכן, עם נתונים, ולקבל תחזיות.

test = pd.read_csv(io.StringIO(raw), sep=",", header=None)
X_test = test.iloc[:, 1:].values
y_test = test.iloc[:, 0:1].values

predicted = predictor.predict(X_test)
for i in range(len(predicted)-1):
    print(f"predicted: {predicted[i]}, actual: {y_test[i][0]}")

מחק את נקודת הקצה

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

predictor.delete_endpoint()

לנקות את

לפני שתסיר את כל המשאבים שיצרת, ודא שכל האפליקציות נמחקות מה- data-scientist-dvc משתמש, כולל כל אפליקציות KernelGateway, כמו גם אפליקציית JupiterServer המוגדרת כברירת מחדל.

לאחר מכן תוכל להרוס את ערימת ה-AWS CDK על ידי הפעלת הפקודה הבאה:

cdk destroy

אם השתמשת בדומיין קיים, הפעל גם את הפקודות הבאות:

# inject your DOMAIN_ID into the configuration file
sed -i 's/<your-sagemaker-studio-domain-id>/'"$DOMAIN_ID"'/' ../update-domain-no-custom-images.json
# update the sagemaker studio domain
aws --region ${REGION} sagemaker update-domain --cli-input-json file://../update-domain-no-custom-images.json

סיכום

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

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

לקריאה נוספת, עיין במשאבים הבאים:

על הכותבים

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

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