הפעל עומסי עבודה של מסקנות למידת מכונה במופעים מבוססי AWS Graviton עם Amazon SageMaker

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

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

סקירה קצרה של Graviton

AWS Graviton היא משפחה של מעבדים שתוכננו על ידי AWS המספקים את ביצועי המחיר הטובים ביותר וחסכוניים יותר באנרגיה מאשר מקביליהם x86. מעבדי AWS Graviton 3 הם העדכניים ביותר במשפחת מעבדי Graviton ומותאמים לעומסי עבודה של ML, כולל תמיכה ב-bfloat16, ורוחב פס פי שניים מרוחב הפס Single Instruction Multiple Data (SIMD). כאשר שתי התכונות הללו משולבות, Graviton 3 יכול לספק עד פי שלושה ביצועים טובים יותר לעומת מופעי Graviton 2. Graviton 3 גם משתמש עד 60% פחות אנרגיה עבור אותם ביצועים כמו דומה ענן מחשוב אלסטי של אמזון (Amazon EC2) מופעים. זוהי תכונה נהדרת אם אתה רוצה להפחית את טביעת הרגל הפחמנית שלך ולהשיג את יעדי הקיימות שלך.

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

כדי לפרוס את המודלים שלך למופעי Graviton, אתה משתמש מיכלי למידה עמוקה של AWS or הביאו מכולות משלכם תואם לארכיטקטורת Arm v8.2.

ההעברה (או הפריסה החדשה) של הדגמים שלך ממופעים מופעלים על ידי x86 למופעי Graviton היא פשוטה מכיוון ש-AWS מספקת קונטיינרים לארח מודלים עם PyTorch, TensorFlow, Scikit-learn ו-XGBoost, והמודלים הם אגנוסטיים לארכיטקטורה. עם זאת, אם אתה מוכן להביא ספריות משלך, אתה יכול גם לעשות זאת, רק וודא שהמכולה שלך בנויה עם סביבה שתומכת בארכיטקטורת Arm64. למידע נוסף, ראה בניית מיכל אלגוריתם משלך.

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

1. צור מודל SageMaker: זה יכיל, בין שאר הפרמטרים, את המידע על מיקום קובץ המודל, הקונטיינר שישמש לפריסה ומיקום סקריפט ההסקה. (אם יש לך מודל קיים שכבר פרוס במופע מסקנות מבוסס x86, תוכל לדלג על שלב זה.)
2. צור תצורת נקודת קצה: זה יכיל מידע על סוג המופע הרצוי עבור נקודת הקצה (לדוגמה, ml.c7g.xlarge עבור Graviton3), שם המודל שיצרת בשלב 1, ומספר המופעים לכל נקודת קצה.
3. הפעל את נקודת הקצה עם תצורת נקודת הקצה שנוצרה בשלב 2.

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

לפני שתתחיל, שקול את התנאים המוקדמים הבאים:

1. השלם את התנאים המוקדמים כמפורט ב תנאים מוקדמים.
2. המודל שלך צריך להיות מודל מבוסס PyTorch, TensorFlow, XGBoost או Scikit Learn. הטבלה הבאה מסכמת את הגרסאות הנתמכות כרגע נכון לכתיבת שורות אלה. לעדכונים האחרונים, עיין ב SageMaker Framework Containers (תמיכה ב-SM בלבד).
   

   .	פיתון	TensorFlow	PyTorch	Scikit-ללמוד	XGBoost
   גרסאות נתמכות	3.8	2.9.1	1.12.1	1.0-1	1.3-1 כדי 1.5-1

3. סקריפט ההסקה מאוחסן ב שירות אחסון פשוט של אמזון (אמזון S3).

בסעיפים הבאים, אנו מדריכים אותך בשלבי הפריסה.

צור מודל של SageMaker

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

1. אתר את הדגם שאחסנת בדלי S3. העתק את ה-URI.
   אתה משתמש בדגם URI מאוחר יותר ב MODEL_S3_LOCATION.
2. זהה את גרסת המסגרת ואת גרסת Python שבה נעשה שימוש במהלך אימון המודל.
   עליך לבחור קונטיינר מרשימת מיכלי הלמידה העמוקים של AWS הזמינים לפי המסגרת וגרסת Python שלך. למידע נוסף, עיין ב הצגת תמונות מיכל מרובות ארכיטקטורות עבור Amazon ECR.
3. אתר את URI הסקריפט של Python בדלי S3 (שם הקובץ הנפוץ הוא inference.py).
   יש צורך ב-URI של סקריפט ההסקה ב- INFERENCE_SCRIPT_S3_LOCATION.
4. עם משתנים אלה, תוכל לקרוא ל- SageMaker API עם הפקודה הבאה:

   client = boto3.client("sagemaker")
   
   client.create_model(
       ModelName="Your model name",
       PrimaryContainer={
           "Image": ,
           "ModelDataUrl": ,
           "Environment": {
           "SAGEMAKER_PROGRAM": "inference.py",
           "SAGEMAKER_SUBMIT_DIRECTORY": ,
           "SAGEMAKER_CONTAINER_LOG_LEVEL": "20",
           "SAGEMAKER_REGION": 
           }
       },
       ExecutionRoleArn= 
   )

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

צור תצורת נקודת קצה

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

client.create_endpoint_config(
    EndpointConfigName= ,
    ProductionVariants=[
        {
         "VariantName": "v0",
         "ModelName": "Your model name",
         "InitialInstanceCount": 1,
         "InstanceType": "ml.c7g.xlarge",
        },
    ]
)

צילום המסך הבא מציג את פרטי תצורת נקודת הקצה בקונסולת SageMaker.

הפעל את נקודת הקצה

עם תצורת נקודת הקצה שנוצרה בשלב הקודם, תוכל לפרוס את נקודת הקצה:

client.create_endpoint(
    EndpointName = "",
    EndpointConfigName = ""
    )

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

צילום המסך הבא מציג את נקודת הקצה שלך בקונסולת SageMaker.

מה נתמך

SageMaker מספקת מיכלי Graviton עמוקים מותאמים לביצועים עבור מסגרות TensorFlow ו- PyTorch. מיכלים אלה תומכים בראייה ממוחשבת, בעיבוד שפה טבעית, בהמלצות ובמקרי שימוש כלליים מבוססי-מודלים עמוקים ורחבים. בנוסף למיכלי למידה עמוקה, SageMaker מספקת גם קונטיינרים למסגרות ML קלאסיות כמו XGBoost ו-Skit-learn. הקונטיינרים תואמים בינאריים על פני מופעי c6g/m6g ו-c7g, ולכן העברת יישום ההסקה מדור אחד למשנהו היא חלקה.

C6g/m6g תומך ב-fp16 (ציפה בחצי דיוק) ובעבור דגמים תואמים מספק ביצועים שווים או טובים יותר בהשוואה למקרים של c5. C7g מגדיל משמעותית את ביצועי ה-ML על ידי הכפלת רוחב ה- SIMD ותמיכה ב-bfloat-16 (bf16), שהיא הפלטפורמה היעילה ביותר להפעלת הדגמים שלך.

גם c6g/m6g וגם c7g מספקים ביצועים טובים עבור ML קלאסי (לדוגמה, XGBoost) בהשוואה למופעי CPU אחרים ב- SageMaker. תמיכה ב-Bfloat-16 ב-c7g מאפשרת פריסה יעילה של דגמים מאומנים bf16 או AMP (Automatic Mixed Precision). ה-Arm Compute Library (ACL) ב-Graviton מספק גרעינים של bfloat-16 שיכולים להאיץ אפילו את האופרטורים של fp32 באמצעות מצב מתמטיקה מהיר, ללא קוונטיזציה של המודל.

שיטות עבודה מומלצות מומלצות

במופעי Graviton, כל vCPU הוא ליבה פיזית. אין ויכוח על משאבי ה-CPU הנפוצים (בניגוד ל-SMT), וקנה המידה של ביצועי עומס העבודה הוא ליניארי עם כל תוספת vCPU. לכן, מומלץ להשתמש בהסקת אצווה בכל פעם שמקרה השימוש מאפשר. זה יאפשר שימוש יעיל במעבדי vCPU על ידי עיבוד מקבילי של האצווה בכל ליבה פיזית. אם ההסקת האצווה אינה אפשרית, נדרש גודל המופע האופטימלי עבור מטען נתון כדי להבטיח שתקורת תזמון חוט של מערכת ההפעלה לא תעלה על כוח המחשוב שמגיע עם ה-vCPUs הנוספים.

TensorFlow מגיע עם ליבות Eigen כברירת מחדל, ומומלץ לעבור ל-OneDNN עם ACL כדי לקבל את ההסקת האחורית המותאמת ביותר. ניתן להפעיל את הקצה האחורי של OneDNN ומצב המתמטיקה המהיר bfloat-16 בזמן השקת שירות המכולה:

docker run -p 8501:8501 --name tfserving_resnet 
--mount type=bind,source=/tmp/resnet,target=/models/resnet 
-e MODEL_NAME=resnet -e TF_ENABLE_ONEDNN_OPTS=1 
-e DNNL_DEFAULT_FPMATH_MODE=BF16 -e -t tfs:mkl_aarch64

פקודת ההגשה הקודמת מארחת דגם resnet50 סטנדרטי עם שתי תצורות חשובות:

-e TF_ENABLE_ONEDNN_OPTS=1
-e DNNL_DEFAULT_FPMATH_MODE=BF16

אלה יכולים להיות מועברים למיכל ההסקה בדרך הבאה:

client.create_model(
    ModelName="Your model name",
    PrimaryContainer={
    "Image": ,
    "ModelDataUrl": ,
    "Environment": {
        "SAGEMAKER_PROGRAM": "inference.py",
        "SAGEMAKER_SUBMIT_DIRECTORY": "",
        "SAGEMAKER_CONTAINER_LOG_LEVEL": "20",
        "SAGEMAKER_REGION": ,
        "TF_ENABLE_ONEDNN_OPTS": "1",
        "DNNL_DEFAULT_FPMATH_MODE": "BF16"
         }
     },
     ExecutionRoleArn='ARN for AmazonSageMaker-ExecutionRole'
)

דוגמה לפריסה

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

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

הדוגמה הבאה מתייחסת למערך הנתונים של CIFAR-10. אתה יכול לעקוב אחר דוגמה של המחברת מהדוגמאות של SageMaker GitHub ריפו כדי לשחזר את הדגם המשמש בפוסט זה. אנו משתמשים במודל המיומן וב- cifar10_keras_main.py סקריפט Python להסקת מסקנות.

הדגם מאוחסן בדלי S3: s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/model.tar.gz

אל האני cifar10_keras_main.py סקריפט, שניתן להשתמש בו עבור ההסקה, מאוחסן ב:s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/script/cifar10_keras_main.py

אנו משתמשים us-east-1 אזור ופרוס את המודל על מופע מבוסס Graviton ml.c7g.xlarge. בהתבסס על זה, ה-URI של מיכל הלמידה העמוק של AWS שלנו הוא 763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-inference-graviton:2.9.1-cpu-py38-ubuntu20.04-sagemaker

1. הגדר עם הקוד הבא:

   import sagemaker
   import boto3
   import datetime
   import json
   import gzip
   import os
   
   sagemaker_session = sagemaker.Session()
   bucket = sagemaker_session.default_bucket()
   role = sagemaker.get_execution_role()
   region = sagemaker_session.boto_region_name

2. הורד את מערך הנתונים לבדיקת נקודות קצה:

   from keras.datasets import cifar10
   (x_train, y_train), (x_test, y_test) = cifar10.load_data()

3. צור את המודל ואת תצורת נקודת הקצה, ופרוס את נקודת הקצה:

   timestamp = "{:%Y-%m-%d-%H-%M-%S}".format(datetime.datetime.now())
   
   client = boto3.client("sagemaker")
   
   MODEL_NAME = f"graviton-model-{timestamp}"
   ENDPOINT_NAME = f"graviton-endpoint-{timestamp}"
   ENDPOINT_CONFIG_NAME = f"graviton-endpoint-config-{timestamp}"
   
   # create sagemaker model
   create_model_response = client.create_model(
       ModelName=MODEL_NAME,
       PrimaryContainer={
       "Image":  "763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-inference-graviton:2.9.1-cpu-py38-ubuntu20.04-sagemaker ",
       "ModelDataUrl":  "s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/model.tar.gz",
       "Environment": {
           "SAGEMAKER_CONTAINER_LOG_LEVEL": "20",
           "SAGEMAKER_REGION": region
           }
       },
       ExecutionRoleArn=role
   )
   print ("create_model API response", create_model_response)

4. לחלופין, אתה יכול להוסיף את סקריפט ההסקה שלך ל Environment in create_model אם לא הוספת אותו במקור כחפץ לדגם SageMaker שלך במהלך האימון:

   "SAGEMAKER_PROGRAM": "inference.py",
   "SAGEMAKER_SUBMIT_DIRECTORY": ,
   		
   # create sagemaker endpoint config
   create_endpoint_config_response = client.create_endpoint_config(
       EndpointConfigName=ENDPOINT_CONFIG_NAME,
       ProductionVariants=[
           {
            "VariantName": "v0",
            "ModelName": MODEL_NAME,
            "InitialInstanceCount": 1,
            "InstanceType": "ml.c7g.xlarge" 
           },
       ]
   )
   print ("ncreate_endpoint_config API response", create_endpoint_config_response)
   
   # create sagemaker endpoint
   create_endpoint_response = client.create_endpoint(
       EndpointName = ENDPOINT_NAME,
       EndpointConfigName = ENDPOINT_CONFIG_NAME,
   )
   print ("ncreate_endpoint API response", create_endpoint_response)   
   

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

5. אמת את מצב נקודת הקצה באמצעות הקוד הבא:

   describe_response = client.describe_endpoint(EndpointName=ENDPOINT_NAME)
   print(describe_response["EndpointStatus"]

   ניתן גם לבדוק את קונסולת הניהול של AWS כדי לראות מתי הדגם שלך נפרס.

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

   runtime = boto3.Session().client(service_name="runtime.sagemaker")

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

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

   input_image = x_test[0].reshape(1,32,32,3)

   אנו מקבלים את פלט המודל כמערך.

8. נוכל להפוך את הפלט הזה להסתברויות אם נחיל עליו softmax:

   CONTENT_TYPE = 'application/json'
   ACCEPT = 'application/json'
   PAYLOAD = json.dumps(input_image.tolist())
   
   response = runtime.invoke_endpoint(
       EndpointName=ENDPOINT_NAME, 
       ContentType=CONTENT_TYPE,
       Accept=ACCEPT,
       Body=PAYLOAD
   )
       
   print(response['Body'].read().decode())

לנקות משאבים

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

client.delete_endpoint(EndpointName=ENDPOINT_NAME)
client.delete_endpoint_config(EndpointConfigName=ENDPOINT_CONFIG_NAME)
client.delete_model(ModelName=MODEL_NAME)

השוואת מחיר-ביצועים

מופעים מבוססי Graviton מציעים את המחיר הנמוך ביותר ואת ביצועי המחיר הטובים ביותר בהשוואה למופעים מבוססי x86. בדומה למקרים של EC2, נקודות הסיום של SageMaker עם מופעי ml.c6g (Graviton 2) מציעים מחיר נמוך ב-20% בהשוואה ל-ml.c5, ומופעי Graviton 3 ml.c7g זולים ב-15% ממופעי ml.c6. למידע נוסף, עיין ב תמחור SageMaker של אמזון.

סיכום

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

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

על המחברים

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

זמנקו אוראהמן, דוקטורט, הוא חבר תרגול, ML SME ו- Machine Learning Community Technical Field (TFC) בשירותי האינטרנט של אמזון. הוא עוזר ללקוחות למנף את כוחו של הענן כדי להפיק ערך מהנתונים שלהם באמצעות ניתוח נתונים ולמידת מכונה.

סוניטה נדמפלי הוא מנהל פיתוח תוכנה ב-AWS. היא מובילה אופטימיזציות של ביצועי תוכנת Graviton עבור השענת מכונה, HPC ועומסי עבודה מולטימדיה. היא נלהבת מפיתוח קוד פתוח ומספקת פתרונות תוכנה חסכוניים עם Arm SoCs.

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

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