פרוס דגמי טייס אוטומטי של Amazon SageMaker לנקודות קצה ללא שרת

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

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

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

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

מצבי אימון של טייס אוטומטי

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

הטייס האוטומטי תומך כעת בשלושה מצבי אימון:

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

למידע נוסף על מצבי אימון של טייס אוטומטי, עיין ב מצבי אימון.

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

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

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

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

למידע נוסף על סוגי בעיות רגרסיה וסיווג, עיין ב הגדרות מיכל היסק עבור סוגי בעיות רגרסיה וסיווג.

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

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

ודא שהגרסה העדכנית ביותר של Boto3 וחבילות SageMaker Python מותקנות:

pip install -U boto3 sagemaker

אנחנו צריכים את גרסת החבילה של SageMaker >= 2.110.0 וגרסת Boto3 >= boto3-1.24.84.

הפעל משימת טייס אוטומטי עם מצב אנסמבלינג

כדי להשיק משימת טייס אוטומטי באמצעות ספריות SageMaker Boto3, אנו משתמשים ב- create_auto_ml_job ממשק API. לאחר מכן אנו עוברים פנימה AutoMLJobConfig, InputDataConfig, ו AutoMLJobObjective בתור תשומות ל- create_auto_ml_job. ראה את הקוד הבא:

bucket = session.default_bucket()
role = sagemaker.get_execution_role()
prefix = "autopilot/bankadditional"
sm_client = boto3.Session().client(service_name='sagemaker',region_name=region)

timestamp_suffix = strftime('%d%b%Y-%H%M%S', gmtime())
automl_job_name = f"uci-bank-marketing-{timestamp_suffix}"
max_job_runtime_seconds = 3600
max_runtime_per_job_seconds = 1200
target_column = "y"
problem_type="BinaryClassification"
objective_metric = "F1"
training_mode = "ENSEMBLING"

automl_job_config = {
    'CompletionCriteria': {
      'MaxRuntimePerTrainingJobInSeconds': max_runtime_per_job_seconds,
      'MaxAutoMLJobRuntimeInSeconds': max_job_runtime_seconds
    },    
    "Mode" : training_mode
}

automl_job_objective= { "MetricName": objective_metric }

input_data_config = [
    {
      'DataSource': {
        'S3DataSource': {
          'S3DataType': 'S3Prefix',
          'S3Uri': f's3://{bucket}/{prefix}/raw/bank-additional-full.csv'
        }
      },
      'TargetAttributeName': target_column
    }
  ]

output_data_config = {
	    'S3OutputPath': f's3://{bucket}/{prefix}/output'
	}


sm_client.create_auto_ml_job(
				AutoMLJobName=auto_ml_job_name,
				InputDataConfig=input_data_config,
				OutputDataConfig=output_data_config,
				AutoMLJobConfig=automl_job_config,
				ProblemType=problem_type,
				AutoMLJobObjective=automl_job_objective,
				RoleArn=role)

הטייס האוטומטי מחזיר את ה BestCandidate אובייקט דגם שיש לו את InferenceContainers נדרש לפרוס את המודלים לנקודות קצה מסקנות. כדי לקבל את BestCandidate עבור העבודה הקודמת, אנו משתמשים ב- describe_automl_job פוּנקצִיָה:

job_response = sm_client.describe_auto_ml_job(AutoMLJobName=automl_job_name)
best_candidate = job_response['BestCandidate']
inference_container = job_response['BestCandidate']['InferenceContainers'][0]
print(inference_container)

פרוס את המודל המאומן

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

אנו ממליצים לבחור את שלך גודל הזיכרון של נקודת הקצה לפי גודל הדגם שלך. גודל הזיכרון צריך להיות גדול לפחות כמו גודל הדגם שלך. לנקודת הקצה ללא שרת שלך יש גודל זיכרון RAM מינימלי של 1024 מגה-בייט (1 ג'יגה-בייט), וגודל ה-RAM המרבי שתוכל לבחור הוא 6144 מגה-בייט (6 ג'יגה-בייט).

גדלי הזיכרון שאתה יכול לבחור הם 1024 MB, 2048 MB, 3072 MB, 4096 MB, 5120 MB או 6144 MB.

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

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

# Create Model
	model_response = sm_client.create_model(
				ModelName=model_name,
				ExecutionRoleArn=role,
				Containers=[inference_container]
	)

# Create Endpoint Config
	epc_response = sm_client.create_endpoint_config(
		EndpointConfigName = endpoint_config_name,
		ProductionVariants=[
			{
				"ModelName": model_name,
				"VariantName": "AllTraffic",
				"ServerlessConfig": {
					"MemorySizeInMB": memory,
					"MaxConcurrency": max_concurrency
				}
			}
		]
	)

# Create Endpoint
	ep_response = sm_client.create_endpoint(
		EndpointName=endpoint_name,
		EndpointConfigName=endpoint_config_name
	)

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

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

שלח בקשת מסקנות לדגם המאומן

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

from sagemaker.predictor import Predictor
from sagemaker.serializers import CSVSerializer


payload = "34,blue-collar,married,basic.4y,no,no,no,telephone,may,tue,800,4,999,0,nonexistent,1.1,93.994,-36.4,4.857,5191.0"

predictor = Predictor(
        endpoint_name=endpoint,
        sagmaker_session=session,
        serializer=CSVSerializer(),
    )

prediction = predictor.predict(payload).decode(‘utf-8’)
print(prediction)

הפעל משימת טייס אוטומטי עם מצב HPO

במצב HPO, עבור CompletionCriteria, חוץ מזה MaxRuntimePerTrainingJobInSeconds ו MaxAutoMLJobRuntimeInSeconds, נוכל גם לציין את MaxCandidates כדי להגביל את מספר המועמדים שעבודת טייס אוטומטי תיצור. שים לב שאלו פרמטרים אופציונליים ומוגדרים רק להגביל את זמן הריצה של העבודה להדגמה. ראה את הקוד הבא:

training_mode = "HYPERPARAMETER_TUNING"

automl_job_config["Mode"] = training_mode
automl_job_config["CompletionCriteria"]["MaxCandidates"] = 15
hpo_automl_job_name =  f"{model_prefix}-HPO-{timestamp_suffix}"

response = sm_client.create_auto_ml_job(
					  AutoMLJobName=hpo_automl_job_name,
					  InputDataConfig=input_data_config,
					  OutputDataConfig=output_data_config,
					  AutoMLJobConfig=automl_job_config,
					  ProblemType=problem_type,
					  AutoMLJobObjective=automl_job_objective,
					  RoleArn=role,
					  Tags=tags_config
				)

כדי להשיג את BestCandidate עבור העבודה הקודמת, נוכל להשתמש שוב ב- describe_automl_job פוּנקצִיָה:

job_response = sm_client.describe_auto_ml_job(AutoMLJobName=automl_job_name)
best_candidate = job_response['BestCandidate']
inference_containers = job_response['BestCandidate']['InferenceContainers']
print(inference_containers)

פרוס את המודל המאומן

טייס אוטומטי במצב HPO עבור סוג בעיית הסיווג יוצר שלושה מיכלי הסקה.

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

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

התרשים הבא ממחיש את הארכיטקטורה של התקנה זו.

אנו מחלצים את שלושת מיכלי ההסקה מה- BestCandidate עם הקוד הבא:

job_response = sm_client.describe_auto_ml_job(AutoMLJobName=automl_job_name)
inference_containers = job_response['BestCandidate']['InferenceContainers']

models = list()
endpoint_configs = list()
endpoints = list()

# For brevity, we've encapsulated create_model, create endpoint_config and create_endpoint as helper functions
for idx, container in enumerate(inference_containers):
    (status, model_arn) = create_autopilot_model(
								    sm_client,
								    automl_job_name,
            						role,
								    container,
								    idx)
    model_name = model_arn.split('/')[1]
    models.append(model_name)

    endpoint_config_name = f"epc-{model_name}"
    endpoint_name = f"ep-{model_name}"
    (status, epc_arn) = create_serverless_endpoint_config(
								    sm_client,
								    endpoint_config_name,
								    model_name,
            						memory=2048,
								    max_concurrency=10)
	endpoint_configs.append(endpoint_config_name)

	response = create_serverless_endpoint(
								    sm_client,
								    endpoint_name,
								    endpoint_config_name)
	endpoints.append(endpoint_name)

שלח בקשת מסקנות לדגם המאומן

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

ראה את הקוד הבא:

from sagemaker.predictor import Predictor
from sagemaker.serializers import CSVSerializer

payload = "51,technician,married,professional.course,no,yes,no,cellular,apr,thu,687,1,0,1,success,-1.8,93.075,-47.1,1.365,5099.1"


for _, endpoint in enumerate(endpoints):
    try:
        print(f"payload: {payload}")
        predictor = Predictor(
            endpoint_name=endpoint,
            sagemaker_session=session,
            serializer=CSVSerializer(),
        )
        prediction = predictor.predict(payload)
        payload=prediction
    except Exception as e:
        print(f"Error invoking Endpoint; {endpoint} n {e}")
        break

היישום המלא של דוגמה זו זמין ב-jupyter הבא מחברה.

לנקות את

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

sm_client = boto3.Session().client(service_name='sagemaker',region_name=region)

for _, endpoint in enumerate(endpoints):
    try:
        sm_client.delete_endpoint(EndpointName=endpoint)
    except Exception as e:
        print(f"Exception:n{e}")
        continue
        
for _, endpoint_config in enumerate(endpoint_configs):
    try:
        sm_client.delete_endpoint_config(EndpointConfigName=endpoint_config)
    except Exception as e:
        print(f"Exception:n{e}")
        continue

for _, autopilot_model in enumerate(models):
    try:
        sm_client.delete_model(ModelName=autopilot_model)
    except Exception as e:
        print(f"Exception:n{e}")
        continue

סיכום

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

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

הפניות נוספות

על המחבר

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