צור דגמי אמזון SageMaker באמצעות גן החיות של PyTorch Model

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

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

אנו עוברים על דוגמה מקצה לקצה, מטעינת משקלי מודל זיהוי האובייקטים של Faster R-CNN ועד לשמירתם ל שירות אחסון פשוט של אמזון (Amazon S3) bucket, וכתיבת קובץ נקודת כניסה והבנת הפרמטרים המרכזיים ב- PyTorchModel API. לבסוף, נפרוס את מודל ה-ML, נבצע עליו הסקה באמצעות SageMaker Batch Transform, ונבדוק את פלט מודל ה-ML ונלמד כיצד לפרש את התוצאות. ניתן ליישם פתרון זה על כל דגם אחר שהוכשר מראש בגן ​​החיות של PyTorch Model. לרשימה של דגמים זמינים, עיין ב- תיעוד PyTorch Model Zoo.

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

פוסט זה בבלוג יעבור על השלבים הבאים. לגרסת עבודה מלאה של כל השלבים, ראה create_pytorch_model_sagemaker.ipynb

• שלב 1: התקנה
• שלב 2: טעינת דגם ML מבית PyTorch Model Zoo
• שלב 3 שמור והעלה חפצים מדגם ML לאמזון S3
• שלב 4: בניית סקריפטים להסקת מודל ML
• שלב 5: השקת עבודת שינוי אצווה של SageMaker
• שלב 6: הדמיית תוצאות

תרשים אדריכלות

מבנה הספריות

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

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

sagemaker_pytorch_model_zoo --> root directory
    |- inference.py --> entry point file
    |- create_pytorch_model_sagemaker.ipynb --> walks through all steps in this blog post
    |- cars.jpg --> input image

השמיים sagemaker_torch_model_zoo התיקיה צריכה להכיל inference.py כקובץ נקודת כניסה, ו-create_pytorch_model_sagemaker.ipynb כדי לטעון ולשמור את משקלי המודל, ליצור אובייקט מודל של SageMaker ולבסוף להעביר את זה לעבודת טרנספורמציה אצווה של SageMaker. על מנת להביא דגמי ML משלכם, שנה את הנתיבים בסעיף שלב 1: התקנה של המחברת וטען דגם חדש בשלב 2: טעינת דגם ML מקטע PyTorch Model Zoo. שאר השלבים הבאים להלן יישארו זהים.

שלב 1: התקנה

תפקידי IAM

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

import sagemaker

session = sagemaker.Session()

# Set a default S3 bucket
default_bucket = session.default_bucket()

# Get the region
region = boto3.Session().region_name

# Get the SageMaker Execution Role
role_arn = sagemaker.get_execution_role()

הקוד לעיל מקבל את תפקיד הביצוע של SageMaker עבור מופע המחברת. זהו תפקיד IAM שיצרנו עבור מופע המחברת של SageMaker או SageMaker Studio.

פרמטרים הניתנים להגדרה על ידי המשתמש

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

INSTANCE_TYPE= "ml.m5.xlarge"
INSTANCE_COUNT= 1
BUCKET = os.path.join("s3://", default_bucket)

DATA_PATH= os.path.join(BUCKET, "images")
IMAGE_NAME = "cars.jpg"
RANDOM_STRING_LENGTH= 16
MODEL_NAME= "FasterRCNNResnet50"

# Needs to be set to version 1.2 or higher to enable automatic PyTorch model repackaging
FRAMEWORK_VERSION= "1.2"
ENTRY_POINT_FILE_NAME= "inference.py"

SAGEMAKER_EXECUTION_ROLE_ARN= role_arn
MODEL_ARTIFACTS_FILE_NAME= os.path.join(BUCKET, "modelzoo/fasterrcnn_resnet50_fpn/model.tar.gz")
IMAGE_URI= sagemaker.image_uris.retrieve(framework="pytorch",
region=region,
version="1.9.1",
py_version="py38",
image_scope='inference',
instance_type=INSTANCE_TYPE)

שלב 2: טעינת דגם ML מגן החיות של PyTorch Model

לאחר מכן, אנו מציינים מודל זיהוי אובייקטים מגן החיות של PyTorch Model ונשמור את משקלי מודל ה-ML שלו. בדרך כלל, אנו שומרים מודל PyTorch באמצעות סיומות הקובץ .pt או .pth. קטע הקוד למטה מוריד דגם Faster R-CNN ResNet50 ML מאומן מראש מגן החיות של PyTorch Model:

model = torchvision.models.detection.fasterrcnn_resnet50_fpn(pretrained=True)

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

H = 1080
W = 1920
scripted_fn = torch.jit.script(model, torch.randn(1, 3, H, W))
scripted_fn.save("model.pt")

שלב 3: שמור והעלה חפצים מדגם ML לאמזון S3

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

הערות: כדי להפעיל את הפקודות הבאות, אתה צריך את ממשק שורת הפקודה AWS (AWS CLI) מותקן.

tar -czvf model.tar.gz model.pt
aws s3 cp model.tar.gz $MODEL_ARTIFACTS_FILE_NAME

לאחר מכן, אנו מעתיקים את תמונת הקלט שלנו ל-S3. להלן נתיב S3 המלא לתמונה.

car_image_path = os.path.join(DATA_PATH, IMAGE_NAME)

אנחנו יכולים להעתיק את התמונה הזו ל-S3 עם פקודת aws s3 cp אחרת.

aws s3 cp cars.jpg $car_image_path

שלב 4: בניית סקריפטים להסקת מודל ML

כעת נעבור על קובץ נקודות הכניסה שלנו, inference.py מודול. אנו יכולים לפרוס מודל PyTorch מאומן מחוץ ל-SageMaker באמצעות מחלקה PyTorchModel. ראשית, אנו מציגים את האובייקט PyTorchModelZoo. לאחר מכן נבנה קובץ נקודת כניסה של inference.py כדי לבצע הסקת ML באמצעות טרנספורמציה אצווה של SageMaker על נתונים לדוגמה המתארחים ב-Amazon S3.

הבנת האובייקט PyTorchModel

השמיים PyTorchModel מחלקה בתוך SageMaker Python API מאפשרת לנו לבצע הסקת ML באמצעות חפץ המודל שהורדנו.

כדי להפעיל את המחלקה PyTorchModel, עלינו להבין את פרמטרי הקלט הבאים:

• name: שם המודל; אנו ממליצים להשתמש בשם הדגם + תאריך שעה, או מחרוזת אקראית + תאריך שעה לייחודיות.
• model_data: URI S3 של חפץ דגם ML ארוז.
• entry_point: קובץ Python המוגדר על ידי המשתמש שישמש את תמונת ההסקת Docker כדי להגדיר מטפלים לבקשות נכנסות. הקוד מגדיר טעינת מודל, עיבוד מקדים של קלט, לוגיקת חיזוי ועיבוד לאחר עיבוד פלט.
• framework_version: יש להגדיר לגרסה 1.2 ומעלה כדי לאפשר אריזת דגמי PyTorch אוטומטית.
• source_dir: הספרייה של קובץ entry_point.
• role: תפקיד IAM להגשת בקשות שירות AWS.
• image_uri: השתמש בתמונת המכולה הזו של Amazon ECR Docker כבסיס לסביבת המחשוב של מודל ML.
• sagemaker_session: מושב SageMaker.
• py_version: גרסת Python לשימוש

קטע הקוד הבא מציג את המחלקה PyTorchModel לביצוע הסקה באמצעות מודל PyTorch שהוכשר מראש:

model = PyTorchModel(
               name=RANDOM_STRING,
               model_data=MODEL_ARTIFACTS_FILE_NAME,
               entry_point=ENTRY_POINT_FILE_NAME,
               framework_version=FRAMEWORK_VERSION,
               role=SAGEMAKER_EXECUTION_ROLE_ARN,
               sagemaker_session=sagemaker_session,
               image_uri=IMAGE_URI,
        )

הבנת קובץ נקודת הכניסה (inference.py)

הפרמטר entry_point מצביע על קובץ Python בשם inference.py. נקודת כניסה זו מגדירה טעינת מודל, עיבוד מקדים של קלט, לוגיקה חיזוי ועיבוד לאחר עיבוד פלט. הוא משלים את קוד ההגשה של מודל ML ב-PyTorch המובנה מראש מיכל למידה עמוקה של SageMaker תמונה.

Inference.py יכיל את הפונקציות הבאות. בדוגמה שלנו, אנו מיישמים את model_fn, input_fn, predict_fn ו output_fn פונקציות לעקוף את ברירת המחדל של מטפל בהסקת PyTorch.

1. model_fn: לוקח ספרייה המכילה נקודות ביקורת של מודל סטטי בתמונת ההסקה. פותח וטוען את המודל מנתיב מוגדר ומחזיר מודל PyTorch.
2. input_fn: מקבל את המטען של הבקשה הנכנסת (request_body) וסוג התוכן של בקשה נכנסת (request_content_type) כקלט. מטפל בפענוח נתונים. יש להתאים את הפונקציה הזו לאיזה קלט המודל מצפה.
3. predict_fn: קורא למודל על נתונים שהוסרו בסידרה ב-input_fn. מבצע חיזוי על האובייקט המורד בסידריאל עם מודל ה-ML הנטען.
4. output_fn: מסדר את תוצאת החיזוי לסוג תוכן התגובה הרצוי. ממירה תחזיות המתקבלות מהפונקציה predict_fn לפורמטים JSON, CSV או NPY.

שלב 5: השקת עבודת שינוי אצווה של SageMaker

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

transformer = model.transformer(instance_type=INSTANCE_TYPE, 
                                instance_count=INSTANCE_COUNT
                                )
transformer.transform(data=DATA_PATH,
                      data_type="S3Prefix",
                      content_type="application/x-image",
                      wait=True
                      )

ראה את התיעוד ליצירת משימת שינוי אצווה בכתובת CreateTransformJob.

שלב 6: הדמיית תוצאות

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

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

ראשית, למשרה תהיה הסטטוס "InProgress". לאחר שזה יסתיים, ראה את שינוי הסטטוס ל'הושלם'.

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

תַחַת תצורת נתוני פלט, נראה נתיב פלט S3. כאן נמצא את פלט ה-ML שלנו.

בחר את נתיב הפלט S3 וראה קובץ [image_name].[file_type].out עם נתוני הפלט שלנו. קובץ הפלט שלנו יכיל רשימה של מיפויים. פלט לדוגמה:

[
  {
    "boxes": [
      [
        214.32322692871094,
        192.18418884277344,
        830.3932495117188,
        521.6996459960938
      ],
      [
        235.6244354248047,
        301.3315734863281,
        253.6448516845703,
        312.3525695800781
      ],
      [
        183.92031860351562,
        291.7759704589844,
        207.28196716308594,
        312.1448669433594
      ],
    ],
    "labels": [
      3,
      3,
      9,
    ],
    "scores": [
      0.8823906183242798,
      0.7710548639297485,
      0.4969744384288788,
    ]
  }
]

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

def get_output_from_s3(s3uri, file_name):
    parsed_url = urlparse(s3uri)
    bucket_name = parsed_url.netloc
    prefix = parsed_url.path[1:]
    s3 = boto3.resource('s3')
    obj = s3.Object(bucket_name, '{}/{}'.format(prefix, file_name))
    return obj.get()["Body"].read().decode('utf-8')
    
# Output path from Batch Transform job
output_path = transformer.output_path

# Get the output file from S3
predictions = get_output_from_s3(output_path, "car.jpg.out")

לאחר מכן, אנו מעבדים את קובץ הפלט הזה ומדמיינים את התחזיות שלנו. להלן אנו מציינים את סף הביטחון שלנו. אנו מקבלים את רשימת השיעורים מה- מיפוי אובייקטים של מערך נתונים של COCO. במהלך ההסקה, המודל דורש רק את טנסור הקלט ומחזיר את התחזיות שעובדו לאחר עיבוד בתור List[Dict[Tensor]], אחת עבור כל תמונת קלט. השדות של ה-Dict הם כדלקמן, כאשר N הוא מספר הגילויים:

1. תיבות (FloatTensor[N, 4]): התיבות החזויות ב [x1, y1, x2, y2] פורמט, עם 0 <= x1 < x2 <= W and 0 <= y1 < y2 <= H, שם W הוא רוחב התמונה ו H הוא גובה התמונה
2. תוויות (Int64Tensor[N]): התוויות החזויות עבור כל זיהוי
3. ציונים (Tensor[N]): ציוני החיזוי עבור כל זיהוי

לפרטים נוספים על הפלט, עיין ב- PyTorch Faster R-CNN FPN תיעוד.

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

def procress_batch_transform_output(predictions):
    predictions = eval(predictions)
    for pred in predictions[1:]:
        pred = pred[0]
        boxes = np.array(pred["boxes"])
        labels = np.array(pred["labels"])
        scores = np.array(pred["scores"])

        scores_idx = scores >= CONF_THRESH
        boxes_meet = boxes[scores_idx, :]
        labels_meet = labels[scores_idx]
        scores_meet = scores[scores_idx]

        labels_str = [CLASSES[i] for i in labels_meet]
        
        # Return a tuple containing labels, label index, score, and bounding box
        processed_predictions =  list(zip(labels_str, labels_meet, scores_meet, boxes_meet))
        return processed_predictions
    
    
def visualize_batch_transform_output(input_image, processed_predictions):
    # read input image from computer
    img = read_image(input_image)
    for label, label_index, score, box in processed_predictions:
        label = label + ", score: " + str(round(score, 2))
        # draw bounding box and fill color
        box = torch.tensor(box)
        box = box.unsqueeze(0)
        img = draw_bounding_boxes(img, box, width=5,labels=[label], font_size=16)

    # transform this image to PIL image
    img = torchvision.transforms.ToPILImage()(img)

    # display output
    img.show()

# Process the predictions in the output file
processed_predictions = procress_batch_transform_output(predictions)
visualize_batch_transform_output("car.jpg", processed_predictions)

לבסוף, אנו מדמיינים את המיפויים הללו כדי להבין את הפלט שלנו.

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

הפעלת הקוד לדוגמה

לקבלת דוגמה מלאה לעבודה, שכבו את הקוד ב- amazon-sagemaker-examples GitHub ולהפעיל את התאים ב- create_pytorch_model_sagemaker.ipynb מחברת.

סיכום

בפוסט זה בבלוג, הצגנו דוגמה מקצה לקצה של ביצוע הסקת ML באמצעות מודל זיהוי אובייקטים מגן החיות של PyTorch Model באמצעות טרנספורמציה אצווה של SageMaker. כיסינו את טעינת המשקולות של מודל זיהוי האובייקטים של Faster R-CNN, שמירתם בדלי S3, כתיבת קובץ נקודת כניסה והבנת הפרמטרים המרכזיים ב- PyTorchModel API. לבסוף, פרסנו את המודל וביצענו הסקת מודל ML, דיזמנו את פלט המודל ולמדנו כיצד לפרש את התוצאות.

על הכותבים

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

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

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

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