שינוי קנה מידה של צמתים להסקת מסקנות באמצעות שינוי קנה מידה אוטומטי

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

כשמגדירים DeployedModel, צריך להגדיר את dedicatedResources.minReplicaCount לערך של 1 לפחות. במילים אחרות, אי אפשר להגדיר את DeployedModel כך שייווצר קנה מידה של 0 צמתים להסקת מסקנות כשהוא לא בשימוש.

לחלופין, אם תאשרו את השימוש בתכונה Scale To Zero (תצוגה מקדימה), תוכלו להגדיר את השדה dedicatedResources.minReplicaCount ל-0, ועומס העבודה יצטמצם לאפס רפליקות כשלא יהיה תעבורה בנקודת הקצה. פרטים נוספים זמינים במאמר Scale To Zero.

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

פריסה ושינוי שבוצעו באופן חלקי

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

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

נקודות הקצה מוגדלות או מוקטנות לפי מכונה, אבל המכסה מחושבת לפי מעבד או מעבד גרפי. לדוגמה, אם המודל שלכם נפרס לסוג מכונה a2-highgpu-2g, כל רפליקה פעילה נספרת כ-24 מעבדי CPU ו-2 מעבדי GPU במסגרת המכסה של הפרויקט. מידע נוסף זמין במאמר מכסות ומגבלות.

צמתי ההסקה להסקת מסקנות באצווה לא מתרחבים באופן אוטומטי. Agent Platform משתמשת ב-BatchDedicatedResources.startingReplicaCount ומתעלמת מ-BatchDedicatedResources.maxReplicaCount.

הגדרות וניצול של טירגוט

כברירת מחדל, אם פורסים מודל בלי משאבי GPU ייעודיים, Gemini Enterprise Agent Platform מגדילה או מקטינה באופן אוטומטי את מספר הרפליקות, כך שהשימוש במעבד תואם לערך היעד שמוגדר כברירת מחדל – 60%.

כברירת מחדל, אם פורסים מודל עם משאבי GPU ייעודיים (אם machineSpec.accelerator_count גדול מ-0), Gemini Enterprise Agent Platform תגדיל או תקטין באופן אוטומטי את מספר הרפליקות, כך שהשימוש במעבד (CPU) או ב-GPU, הגבוה מביניהם, יתאים לערך היעד של 60% שמוגדר כברירת מחדל. לכן, אם קצב ההעברה של ההיקש גורם לשימוש גבוה ב-GPU, אבל לא לשימוש גבוה ב-CPU, Agent Platform תבצע הרחבה אנכית, והשימוש ב-CPU יהיה נמוך מאוד, וזה יופיע במעקב. לעומת זאת, אם קונטיינר מותאם אישית לא מנצל את ה-GPU באופן מלא, אבל יש בו תהליך לא קשור שמעלה את ניצול המעבד (CPU) מעל 60%, Agent Platform תבצע הרחבה אנכית (scale up), גם אם זה לא היה נחוץ כדי להשיג את יעדי ה-QPS וההשהיה.

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

המדדים הבאים של שינוי גודל אוטומטי נתמכים:

  • ניצול יחידת העיבוד המרכזית (CPU) (aiplatform.googleapis.com/prediction/online/cpu/utilization): הערך משתנה בהתאם לשימוש ב-CPU. היחידה היא ניצול CPU לכל עותק. ערך היעד הוא אחוז (0-100). ערך היעד שמוגדר כברירת מחדל הוא 60%.
  • ניצול המעבד הגרפי (GPU) (aiplatform.googleapis.com/prediction/online/accelerator/duty_cycle): הערך משתנה בהתאם לשימוש במעבד הגרפי. היחידה שלה היא ניצול GPU לכל רפליקה. ערך היעד הוא אחוז (0-100). ערך היעד שמוגדר כברירת מחדל הוא 60%.
  • ניצול ה-GPU של DCGM (תצוגה מקדימה)(prometheus.googleapis.com/vertex_dcgm_fi_dev_gpu_util): המדד הזה מחושב על סמך מדדי DCGM לניצול ה-GPU. היחידה שלה היא ניצול GPU לכל רפליקה. ערך היעד הוא אחוז (0-100). המדד הזה מושבת כברירת מחדל.
  • אחוז השימוש במטמון KV של GPU ב-vLLM (בגרסת טרום-השקה)(prometheus.googleapis.com/vertex_vllm_gpu_cache_usage_perc): הסולם מבוסס על מדדים של vLLM לגבי אחוז השימוש במטמון KV של GPU. היחידה שלו היא אחוז השימוש במטמון GPU KV לכל עותק. ערך היעד הוא אחוז (0-100). המדד הזה מושבת כברירת מחדל.
  • מספר הבקשות בהמתנה של vLLM (גרסת Preview)(prometheus.googleapis.com/vertex_vllm_num_requests_waiting): המדד הזה מותאם לפי מדדי vLLM של מספר הבקשות בהמתנה. היחידה שלו היא מספר הבקשות בהמתנה לכל עותק. ערך היעד הוא מספר שלם. המדד הזה מושבת כברירת מחדל.
  • מספר הבקשות (aiplatform.googleapis.com/prediction/online/request_count): הערך משתנה בהתאם למספר הבקשות. היחידה היא בקשות לדקה לכל עותק. ערך היעד הוא מספר שלם. המדד הזה מושבת כברירת מחדל.
  • ‫Pub/Sub Queue Size (תצוגה מקדימה, ללא תמיכה ב-Google Cloud CLI) ‏(pubsub.googleapis.com/subscription/num_undelivered_messages): ההתאמה מתבצעת על סמך מספר ההודעות שלא נמסרו במינוי Pub/Sub. היחידה היא מספר ההודעות שלא נמסרו לכל עותק משוכפל. ערך היעד הוא מספר שלם. המדד הזה מושבת כברירת מחדל.

כשמגדירים שינוי גודל אוטומטי, משתמשים ב-METRIC_NAME כמזהה המדד וב-TARGET_THRESHOLD כערך היעד.

הגדרת התאמה אוטומטית לעומס (autoscaling) במהלך הפריסה

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

gcloud

כדי להגדיר התאמה אוטומטית לעומס כשפורסים מודל באמצעות ה-CLI של gcloud, משתמשים בפקודה gcloud ai endpoints deploy-model.

שימו לב: מילת המפתח של המדד ב-Google Cloud CLI שונה מעט. מומלץ להשתמש במשאבים הבאים:

  • cpu-usage
  • gpu-duty-cycle
  • dcgm-fi-dev-gpu-util
  • vllm-gpu-cache-usage-perc
  • vllm-num-requests-waiting
  • request-counts-per-minute

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

  • ‫ENDPOINT_ID: המזהה של נקודת הקצה.
  • ‫PROJECT_ID: מזהה הפרויקט.
  • ‫LOCATION: האזור של נקודת הקצה.
  • ‫MODEL_ID: המזהה של המודל שרוצים לפרוס.
  • ‫MACHINE_TYPE: סוג המכונה של המודל שנפרס (לדוגמה, n1-standard-4).
  • ‫ACCELERATOR_TYPE: אופציונלי. סוג מאיץ ה-GPU לצירוף (למשל, NVIDIA_L4).
  • ‫ACCELERATOR_COUNT: אופציונלי. מספר המאיצים לצירוף לכל מכונה.
  • ‫MIN_REPLICA_COUNT: מספר העותקים המינימלי להרחבה אוטומטית.
  • ‫MAX_REPLICA_COUNT: המספר המקסימלי של רפליקות להתאמה אוטומטית לעומס.
  • ‫METRIC_NAME_GCLOUD: המזהה של מדד ההתאמה לעומס.
  • ‫TARGET_THRESHOLD: ערך היעד של המדד שצוין.
gcloud ai endpoints deploy-model ENDPOINT_ID \
    --project=PROJECT_ID \
    --region=LOCATION \
    --model=MODEL_ID \
    --display-name=DEPLOYED_MODEL_DISPLAY_NAME \
    --machine-type=MACHINE_TYPE \
    --accelerator-type=ACCELERATOR_TYPE \
    --accelerator-count=ACCELERATOR_COUNT \
    --min-replica-count=MIN_REPLICA_COUNT \
    --max-replica-count=MAX_REPLICA_COUNT \
    --autoscaling-metric-specs=METRIC_NAME_GCLOUD=TARGET_THRESHOLD

REST

כדי להגדיר התאמה אוטומטית לעומס כשפורסים מודל באמצעות API בארכיטקטורת REST, משתמשים ב-method‏ projects.locations.endpoints.deployModel.

לפני שמשתמשים בנתוני הבקשה, צריך להחליף את הנתונים הבאים:

  • ‫ENDPOINT_ID: המזהה של נקודת הקצה.
  • ‫PROJECT_ID: מזהה הפרויקט.
  • ‫LOCATION: האזור של נקודת הקצה.
  • ‫MODEL_ID: המזהה של המודל שרוצים לפרוס.
  • ‫DEPLOYED_MODEL_DISPLAY_NAME: שם מוצג למודל שנפרס.
  • ‫MACHINE_TYPE: סוג המכונה של המודל שנפרס (לדוגמה, n1-standard-4).
  • ‫ACCELERATOR_TYPE: אופציונלי. סוג מאיץ ה-GPU לצירוף (למשל, NVIDIA_L4).
  • ‫ACCELERATOR_COUNT: אופציונלי. מספר המאיצים לצירוף לכל מכונה.
  • ‫MIN_REPLICA_COUNT: מספר העותקים המינימלי להרחבה אוטומטית.
  • ‫MAX_REPLICA_COUNT: המספר המקסימלי של רפליקות להתאמה אוטומטית לעומס.
  • ‫METRIC_NAME: המזהה של מדד ההתאמה לעומס.
  • ‫TARGET_THRESHOLD: ערך היעד של המדד שצוין.

ה-method של ה-HTTP וכתובת ה-URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/endpoints/ENDPOINT_ID:deployModel

תוכן בקשת JSON:

{
  "deployedModel": {
    "model": "projects/PROJECT_ID/locations/LOCATION/models/MODEL_ID",
    "displayName": "DEPLOYED_MODEL_DISPLAY_NAME",
    "dedicatedResources": {
      "machineSpec": {
        "machineType": "MACHINE_TYPE",
        "acceleratorType": "ACCELERATOR_TYPE",
        "acceleratorCount": ACCELERATOR_COUNT
      },
      "minReplicaCount": MIN_REPLICA_COUNT,
      "maxReplicaCount": MAX_REPLICA_COUNT,
      "autoscalingMetricSpecs": [
        {
          "metricName": "METRIC_NAME",
          "target": TARGET_THRESHOLD
        }
      ]
    }
  }
}

כדי להשתמש בסקייל אוטומטי על סמך מדדי גודל התור של Pub/Sub (גרסת Preview), צריך לספק מידע נוסף על המינוי ל-Pub/Sub:

  • ‫PUBSUB_SUBSCRIPTION_PROJECT_ID: מזהה הפרויקט של מינוי ה-Pub/Sub.
  • ‫PUBSUB_SUBSCRIPTION_ID: המזהה של המינוי ל-Pub/Sub. האורך המקסימלי של השדה הוא 63 תווים.
      "autoscalingMetricSpecs": [
        {
          "metricName": "METRIC_NAME",
          "target": TARGET_THRESHOLD,
          "monitoredResourceLabels": {
            "project_id": "PUBSUB_SUBSCRIPTION_PROJECT_ID",
            "subscription_id": "PUBSUB_SUBSCRIPTION_ID"
          },
        }
      ]

Python

ההגדרה של שינוי גודל אוטומטי ב-Python SDK מתבצעת באמצעות שמות פרמטרים בקריאה לפונקציה deploy(). בדוגמה של הפקודה נעשה שימוש בהתאמה אוטומטית לעומס על בסיס בו-זמניות (concurrency). הפרמטרים של ההתאמה האוטומטית לעומס שאפשר להגדיר הם:

  • autoscaling_target_cpu_utilization
  • autoscaling_target_accelerator_duty_cycle
  • autoscaling_target_dcgm_fi_dev_gpu_util
  • autoscaling_target_vllm_gpu_cache_usage_perc
  • autoscaling_target_vllm_num_requests_waiting
  • autoscaling_target_request_count_per_minute

כדי להגדיר התאמה אוטומטית לעומס כשפורסים מודל באמצעות Agent Platform SDK ל-Python:

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

  • ‫PROJECT_ID: מזהה הפרויקט.
  • ‫LOCATION: האזור של נקודת הקצה.
  • ‫ENDPOINT_ID: המזהה של נקודת הקצה.
  • ‫MODEL_ID: המזהה של המודל לפריסה.
  • ‫DEPLOYED_MODEL_DISPLAY_NAME: שם מוצג למודל שנפרס.
  • ‫MACHINE_TYPE: סוג המכונה של המודל שנפרס (לדוגמה, n1-standard-4).
  • ‫ACCELERATOR_TYPE: אופציונלי. סוג מאיץ ה-GPU לצירוף (למשל, NVIDIA_L4).
  • ‫ACCELERATOR_COUNT: אופציונלי. מספר המאיצים לצירוף לכל מכונה.
  • ‫MIN_REPLICA_COUNT: מספר העותקים המינימלי להרחבה אוטומטית.
  • ‫MAX_REPLICA_COUNT: המספר המקסימלי של רפליקות להתאמה אוטומטית לעומס.
  • ‫METRIC_NAME: המזהה של מדד ההתאמה לעומס.
  • ‫TARGET_THRESHOLD: ערך היעד של המדד שצוין.
from google.cloud import aiplatform

# Initialize Agent Platform
aiplatform.init(project="PROJECT_ID", location="LOCATION")

# Get the model from Model Registry
model = aiplatform.Model("MODEL_ID")

# Get the endpoint
endpoint = aiplatform.Endpoint("ENDPOINT_ID")

# Deploy the model to the endpoint
model.deploy(
  endpoint=endpoint,
  machine_type="MACHINE_TYPE",
  accelerator_type="ACCELERATOR_TYPE",
  accelerator_count=ACCELERATOR_COUNT,
  min_replica_count=MIN_REPLICA_COUNT,
  max_replica_count=MAX_REPLICA_COUNT,
  autoscaling_target_request_count_per_minute=TARGET_THRESHOLD,
)

כדי להשתמש בהתאמה אוטומטית לעומס שמבוססת על מדדי גודל התור של Pub/Sub (גרסת טרום-השקה (Preview), נתמכת רק aiplatform_v1beta1), צריך לספק מידע נוסף על המינוי ל-Pub/Sub:

  • ‫PUBSUB_SUBSCRIPTION_PROJECT_ID: מזהה הפרויקט של מינוי ה-Pub/Sub.
  • ‫PUBSUB_SUBSCRIPTION_ID: המזהה של המינוי ל-Pub/Sub.
from google.cloud import aiplatform_v1beta1 as aiplatform
from google.api_core.client_options import ClientOptions

# Initialize the EndpointServiceClient
client_options = ClientOptions(api_endpoint="LOCATION-aiplatform.googleapis.com")
client = aiplatform.EndpointServiceClient(client_options=client_options)

# Specify the location
location = "projects/PROJECT_NUMBER/locations/LOCATION"

model_name = "projects/PROJECT_NUMBER/locations/LOCATION/models/MODEL_ID"
autoscaling_metric_specs = [
    {"metric_name": "pubsub.googleapis.com/subscription/num_undelivered_messages", "target": TARGET_THRESHOLD, "monitored_resource_labels":{"project_id": "PUBSUB_SUBSCRIPTION_PROJECT_ID","subscription_id": "PUBSUB_SUBSCRIPTION_ID"}}
]

deployed_model = aiplatform.DeployedModel(
    model=model_name,
    display_name="DEPLOYED_MODEL_DISPLAY_NAME",
    dedicated_resources=aiplatform.DedicatedResources(
        machine_spec=aiplatform.MachineSpec(
            machine_type="MACHINE_TYPE"
        ),
        min_replica_count=MIN_REPLICA_COUNT,
        max_replica_count=MAX_REPLICA_COUNT,
        autoscaling_metric_specs=autoscaling_metric_specs
    )
)

deploy_request = aiplatform.DeployModelRequest(
    deployed_model=deployed_model,
    endpoint="projects/PROJECT_NUMBER/locations/LOCATION/endpoints/ENDPOINT_ID",
    traffic_split={"0": 100}
)

deploy_operation = client.deploy_model(deploy_request)
print("Long-running operation initiated to deploy model.")
deploy_operation.result()

print("Model deployed to endpoint.")

עדכון הגדרת התאמה אוטומטית לעומס

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

REST

כדי לעדכן את הגדרות ההתאמה האוטומטית לעומס של מודל שפרסתם באמצעות API בארכיטקטורת REST, צריך להשתמש בשיטה projects.locations.endpoints.mutateDeployedModel.

לפני שמשתמשים בנתוני הבקשה, צריך להחליף את הנתונים הבאים:

  • ‫ENDPOINT_ID: המזהה של נקודת הקצה.
  • ‫PROJECT_ID: מזהה הפרויקט.
  • ‫LOCATION: האזור של נקודת הקצה.
  • ‫DEPLOYED_MODEL_ID: המזהה של המודל הפרוס שרוצים לעדכן.
  • MIN_REPLICA_COUNT: המספר המינימלי החדש של רפליקות לצורך התאמה אוטומטית לעומס.
  • ‫MAX_REPLICA_COUNT: המספר המקסימלי החדש של רפליקות לצורך התאמה אוטומטית לעומס.
  • ‫METRIC_NAME: המזהה של מדד ההתאמה לעומס.
  • ‫TARGET_THRESHOLD: ערך היעד של המדד שצוין.

ה-method של ה-HTTP וכתובת ה-URL:

PATCH https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/endpoints/ENDPOINT_ID:mutateDeployedModel

תוכן בקשת JSON:

{
  "deployedModel": {
    "id": "DEPLOYED_MODEL_ID",
    "dedicatedResources": {
      "minReplicaCount": MIN_REPLICA_COUNT,
      "maxReplicaCount": MAX_REPLICA_COUNT,
      "autoscalingMetricSpecs": [
        {
          "metricName": "METRIC_NAME",
          "target": TARGET_THRESHOLD
        }
      ]
    }
  },
  "updateMask": {
    "paths": [
      "dedicated_resources.min_replica_count",
      "dedicated_resources.max_replica_count",
      "dedicated_resources.autoscaling_metric_specs"
    ]
  }
}

כדי להשתמש בסקייל אוטומטי שמבוסס על מדדים של גודל התור ב-Pub/Sub (גרסת Preview), צריך לספק מידע נוסף על המינוי ל-Pub/Sub:

  • ‫PUBSUB_SUBSCRIPTION_PROJECT_ID: מזהה הפרויקט של מינוי ה-Pub/Sub.
  • ‫PUBSUB_SUBSCRIPTION_ID: המזהה של המינוי ל-Pub/Sub.
      "autoscalingMetricSpecs": [
        {
          "metricName": "METRIC_NAME",
          "target": TARGET_THRESHOLD,
          "monitoredResourceLabels": {
            "project_id": "PUBSUB_SUBSCRIPTION_PROJECT_ID",
            "subscription_id": "PUBSUB_SUBSCRIPTION_ID"
          },
        }
      ]

צמצום הפעולה לאפס (תצוגה מקדימה)

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

כשתנועה מגיעה לנקודת הקצה (endpoint) של היעד שהוקטן, מתקבלת תגובה 429 - Model is not yet ready for inference. Please wait while model completes scale-up from zero, then try your request again, הבקשה נדחית ואות להגדלת קנה המידה נשלח לשרת של מודל היעד.

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

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

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

הפעלה ושימוש

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

כדי להפעיל את התכונה Scale To Zero, צריך לציין min_replica_count=0 בקטע DedicatedResources של בקשת הפריסה של המודל (בגרסה v1beta1 של Vertex Prediction API).

פרמטרים אופציונליים

ב-DedicatedResources, אפשר לציין ערך initial_replica_count בין 1 ל-max_replica_count (כולל).

נוסף גם קטע חדש ScaleToZeroSpec אל DedicatedResources שמאפשר הגדרה של שני פרמטרים שקשורים ל-Scale to Zero:

  • ‫min_scaleup_period: משך הזמן (בשניות) לפני ששרת מודלים נרשם להערכה של Scale to Zero. הפריסה לא תנסה לצמצם את מספר הרפליקות בחזרה לאפס עד שתקופת הזמן הזו תסתיים, גם אם לא תהיה תנועה. הערך הזה מאפשר ליצור ערך חוצץ במהלך הפריסה הראשונית ואירועי הגדלה עוקבים לפני בדיקת התנועה מול נקודת הקצה של היעד (מה שעשוי להוביל להקטנת הפריסה).
    • ערך ברירת המחדל: שעה אחת (3,600 שניות)
    • ערך מינימלי: 5 דקות (300 שניות)
    • הערך המקסימלי: 8 שעות (28,800 שניות).
  • ‫idle_scaledown_period: משך הזמן (בשניות) שבו לא מתקבלת תנועה לפני הקטנת קנה המידה של שרת מודל היעד לאפס עותקים משוכפלים.
    • ערך ברירת המחדל: שעה אחת (3,600 שניות)
    • ערך מינימלי: 5 דקות (300 שניות)
    • הערך המקסימלי: 8 שעות (28,800 שניות).

התנהגויות צפויות

בקשה שנשלחת למודל שהוקטן תחזיר תגובה 429 עם Model is not yet ready for inference. Please wait and then try your request again.

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

מגבלות

  • התכונה Scale To Zero תואמת רק לפריסות של מודל יחיד ולמודל אחד לכל נקודת קצה.
  • התכונה Scale To Zero לא תומכת בפריסות של GPU או TPU בכמה מארחים. עם זאת, פריסות של GPU או TPU במארח יחיד תואמות.
  • אי אפשר להפעיל את התכונה Scale To Zero בנקודות קצה ציבוריות משותפות, אבל היא תואמת לכל סוגי נקודות הקצה האחרים.
  • בלי הזמנות, יכול להיות שתיתקלו במצב של חוסר במלאי כשמגדילים את הקיבולת אחרי הקטנה (בהתאם לסוג המכונה).

  • מודלים מסוג DeployedModel שההיקף שלהם הוקטן לאפס למשך יותר מ-30 ימים (כי הם לא קיבלו תנועה) מבוטלים באופן אוטומטי.

gcloud

כדי להגדיר את התכונה 'צמצום הפעולה לאפס' כשפורסים מודל באמצעות ה-CLI של gcloud, משתמשים בפקודה gcloud beta ai endpoints deploy-model.

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

  • ‫ENDPOINT_ID: המזהה של נקודת הקצה.
  • ‫PROJECT_ID: מזהה הפרויקט.
  • ‫LOCATION: האזור של נקודת הקצה.
  • ‫MODEL_ID: המזהה של המודל שרוצים לפרוס.
  • ‫MACHINE_TYPE: סוג המכונה של המודל שנפרס (לדוגמה, n1-standard-4).
  • ‫ACCELERATOR_TYPE: אופציונלי. סוג מאיץ ה-GPU לצירוף (למשל, NVIDIA_L4).
  • ‫ACCELERATOR_COUNT: אופציונלי. מספר המאיצים לצירוף לכל מכונה.
  • ‫MIN_REPLICA_COUNT: מספר העותקים המינימלי להרחבה אוטומטית.
  • ‫MAX_REPLICA_COUNT: המספר המקסימלי של רפליקות להתאמה אוטומטית לעומס.
gcloud beta ai endpoints deploy-model ENDPOINT_ID \
    --project=PROJECT_ID \
    --region=LOCATION \
    --model=MODEL_ID \
    --display-name=DEPLOYED_MODEL_DISPLAY_NAME \
    --machine-type=MACHINE_TYPE \
    --accelerator-type=ACCELERATOR_TYPE \
    --accelerator-count=ACCELERATOR_COUNT \
    --min-replica-count=MIN_REPLICA_COUNT \
    --max-replica-count=MAX_REPLICA_COUNT \
    --min-scaleup-period=300s \
    --idle-scaledown-period=300s

REST

כדי להגדיר את התכונה צמצום הפעולה לאפס כשפורסים מודל באמצעות ה-API בארכיטקטורת REST, משתמשים ב-method ‏projects.locations.endpoints.deployModel.

לפני שמשתמשים בנתוני הבקשה, צריך להחליף את הנתונים הבאים:

  • ‫ENDPOINT_ID: המזהה של נקודת הקצה.
  • ‫PROJECT_ID: מזהה הפרויקט.
  • ‫LOCATION: האזור של נקודת הקצה.
  • ‫MODEL_ID: המזהה של המודל שרוצים לפרוס.
  • ‫DEPLOYED_MODEL_DISPLAY_NAME: שם מוצג למודל שנפרס.
  • ‫MACHINE_TYPE: סוג המכונה של המודל שנפרס (לדוגמה, n1-standard-4).
  • ‫ACCELERATOR_TYPE: אופציונלי. סוג מאיץ ה-GPU לצירוף (למשל, NVIDIA_L4).
  • ‫ACCELERATOR_COUNT: אופציונלי. מספר המאיצים לצירוף לכל מכונה.
  • ‫MIN_REPLICA_COUNT: מספר העותקים המינימלי להרחבה אוטומטית.
  • ‫MAX_REPLICA_COUNT: המספר המקסימלי של רפליקות להתאמה אוטומטית לעומס.

ה-method של ה-HTTP וכתובת ה-URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/endpoints/ENDPOINT_ID:deployModel

תוכן בקשת JSON:

{
  "deployedModel": {
    "model": "projects/PROJECT_ID/locations/LOCATION/models/MODEL_ID",
    "displayName": "DEPLOYED_MODEL_DISPLAY_NAME",
    "dedicatedResources": {
      "machineSpec": {
        "machineType": "MACHINE_TYPE",
        "acceleratorType": "ACCELERATOR_TYPE",
        "acceleratorCount": ACCELERATOR_COUNT
      },
      "minReplicaCount": MIN_REPLICA_COUNT,
      "maxReplicaCount": MAX_REPLICA_COUNT,
      "scale_to_zero_spec": {
          "min_scaleup_period": "300s",
          "idle_scaledown_period": "300s",
      },
    }
  }
}

Python

הגדרת ה-SDK של Python לצמצום הפעולה לאפס מתבצעת דרך לקוח API v1beta1.

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

  • ‫PROJECT_ID: מזהה הפרויקט.
  • ‫LOCATION: האזור של נקודת הקצה.
  • ‫ENDPOINT_ID: המזהה של נקודת הקצה.
  • ‫MODEL_ID: המזהה של המודל לפריסה.
  • ‫DEPLOYED_MODEL_DISPLAY_NAME: שם מוצג למודל שנפרס.
  • ‫MACHINE_TYPE: סוג המכונה של המודל שנפרס (לדוגמה, n1-standard-4).
  • ‫ACCELERATOR_TYPE: אופציונלי. סוג מאיץ ה-GPU לצירוף (למשל, NVIDIA_L4).
  • ‫ACCELERATOR_COUNT: אופציונלי. מספר המאיצים לצירוף לכל מכונה.
  • ‫MIN_REPLICA_COUNT: מספר העותקים המינימלי להרחבה אוטומטית.
  • ‫MAX_REPLICA_COUNT: המספר המקסימלי של רפליקות להתאמה אוטומטית לעומס.
  • ‫METRIC_NAME: המזהה של מדד ההתאמה לעומס.
  • ‫TARGET_THRESHOLD: ערך היעד של המדד שצוין.
from google.cloud import aiplatform

# Initialize Agent Platform
aiplatform.init(project="PROJECT_ID", location="LOCATION")

# Get the model from Model Registry
model = aiplatform.Model("MODEL_ID")

# Get the endpoint
endpoint = aiplatform.Endpoint("ENDPOINT_ID")

# Deploy the model to the endpoint
model.deploy(
  endpoint=endpoint,
  machine_type="MACHINE_TYPE",
  accelerator_type="ACCELERATOR_TYPE",
  accelerator_count=ACCELERATOR_COUNT
  min_replica_count=MIN_REPLICA_COUNT,
  max_replica_count=MAX_REPLICA_COUNT,
  autoscaling_target_request_count_per_minute=TARGET_THRESHOLD,
)

import google.auth.transport.requests
import urllib3

# pip install google-cloud-aiplatform for this dependency
from google.cloud import aiplatform
from google.cloud.aiplatform_v1beta1.services import endpoint_service # For EndpointServiceClient
from google.cloud.aiplatform_v1beta1 import types as aiplatform_v1beta1_types # For message types

PROJECT_NUMBER = "PROJECT_ID"
LOCATION = "LOCATION"
ENDPOINT_DISPLAY_NAME = "stz-sdk-test"
MODEL_ID="MODEL_ID"

# Full resource name of your existing model in Model Registry
# e.g., "projects/your-gcp-project-id/locations/us-central1/models/your-model-id"
MODEL_RESOURCE_NAME = f"projects/{PROJECT_NUMBER}/locations/{LOCATION}/models/{MODEL_ID}"

# Deployment settings
MACHINE_TYPE = "MACHINE_TYPE"
ACCELERATOR_TYPE ="ACCELERATOR_TYPE",
ACCELERATOR_COUNT =ACCELERATOR_COUNT

# Disable InsecureRequestWarning for the requests part as in your snippet
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

# The AI Platform services require regional API endpoints.
client_options = {"api_endpoint": f"{LOCATION}-aiplatform.googleapis.com"}
endpoint_service_client = endpoint_service.EndpointServiceClient(client_options=client_options)

def main():
    aiplatform.init(project=PROJECT_NUMBER, location=LOCATION)
    model_to_deploy = aiplatform.Model(model_name=MODEL_RESOURCE_NAME) # Initialize model object

    try:
        # # --- 1. Create an Endpoint ---
        print(f"\nCreating endpoint '{ENDPOINT_DISPLAY_NAME}'...")
        endpoint = aiplatform.Endpoint.create(
            display_name=ENDPOINT_DISPLAY_NAME,
            project=PROJECT_NUMBER,
            location=LOCATION,
            sync=True, # Wait for creation to complete
            dedicated_endpoint_enabled=True,
        )
        print(f"Endpoint created: {endpoint.resource_name}")
        endpoint_numeric_id = endpoint.name # This is the numeric ID
        print(f"Numeric Endpoint ID for URL: {endpoint_numeric_id}")

        print(f"\nFetching model details for: {MODEL_RESOURCE_NAME}")
        model_to_deploy = aiplatform.Model(model_name=MODEL_RESOURCE_NAME)

        # --- 2. Deploy the Model ---
        print(f"\nDeploying model '{model_to_deploy.resource_name}' to endpoint '{endpoint.display_name}'...")
        deployed_model_config = aiplatform_v1beta1_types.DeployedModel(
            model=model_to_deploy.resource_name,
            dedicated_resources=aiplatform_v1beta1_types.DedicatedResources(
                machine_spec=aiplatform_v1beta1_types.MachineSpec(
                    machine_type=MACHINE_TYPE,
                    accelerator_type=ACCELERATOR_TYPE,
                    accelerator_count=ACCELERATOR_COUNT,
                ),
                initial_replica_count=1,
                min_replica_count=0,
                max_replica_count=1,
                scale_to_zero_spec=aiplatform_v1beta1_types.DedicatedResources.ScaleToZeroSpec(
                    min_scaleup_period=300,
                    idle_scaledown_period=300,
                )
            ),
        )

        deploy_model_request = aiplatform_v1beta1_types.DeployModelRequest(
            endpoint=endpoint.resource_name,
            deployed_model=deployed_model_config,
        )

        # Alternatively, if you've got an existing endpoint, use:
        # endpoint_path = endpoint_service_client.endpoint_path(
        #     project=PROJECT_NUMBER, location=LOCATION, endpoint={ENDPOINT_ID}
        # )

        # deploy_model_request = aiplatform_v1beta1_types.DeployModelRequest(
        #     endpoint=endpoint_path,
        #     deployed_model=deployed_model_config,
        # )

        print("\nSending v1beta1 DeployModelRequest...")
        operation = endpoint_service_client.deploy_model(request=deploy_model_request)

        print("Waiting for v1beta1 update deploy model operation to complete (this can take several minutes)...")
        operation.result()
        print("Model deployed successfully.")

    except Exception as e:
        print(f"\nAn error occurred: {e}")

if __name__ == "__main__":
    main()

ניהול השימוש במשאבים

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

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

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

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

התנהגות ההתאמה לגודל והשהיה

פלטפורמת Gemini Enterprise Agent משנה את מספר הרפליקות כל 15 שניות באמצעות נתונים מחלון הזמן הקודם של 5 דקות. בכל מחזור של 15 שניות, המערכת מודדת את ניצול השרת ומפיקה מספר יעד של רפליקות על סמך הנוסחה הבאה:

target # of replicas = Ceil(current # of replicas * (current utilization / target utilization))

לדוגמה, אם יש לכם שני עותקים משוכפלים שנמצאים בשימוש ב-100%, היעד הוא 4:

4 = Ceil(3.33) = Ceil(2 * (100% / 60%))

דוגמה נוספת: אם יש לכם 10 רפליקות והניצול יורד ל-1%, היעד הוא 1:

1 = Ceil(.167) = Ceil(10 * (1% / 60%))

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

חשוב לזכור: גם אחרי ש-Gemini Enterprise Agent Platform משנה את מספר הרפליקות, לוקח זמן עד שהרפליקות מופעלות או מושבתות. לכן יש עיכוב נוסף לפני שנקודת הקצה יכולה להסתגל לתנועה. הגורמים העיקריים שמשפיעים על הזמן הזה כוללים את הדברים הבאים:

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

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

עדכון הגדרת קנה המידה

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

לדוגמה, הבקשה הבאה מעדכנת את max_replica ואת autoscaling_metric_specs ומשביתה את רישום היומנים של מאגר התגים.

{
  "deployedModel": {
    "id": "2464520679043629056",
    "dedicatedResources": {
      "maxReplicaCount": 9,
      "autoscalingMetricSpecs": [
        {
          "metricName": "aiplatform.googleapis.com/prediction/online/cpu/utilization",
          "target": 50
        }
      ]
    },
    "disableContainerLogging": true
  },
  "update_mask": {
    "paths": [
      "dedicated_resources.max_replica_count",
      "dedicated_resources.autoscaling_metric_specs",
      "disable_container_logging"
    ]
  }
}

הערות שימוש:

  • אי אפשר לשנות את סוג המכונה או לעבור מ-DedicatedResources ל-AutomaticResources או להיפך. השדות היחידים של הגדרות שינוי הגודל שאפשר לשנות הם: min_replica,‏ max_replica,‏ required_replica ו-AutoscalingMetricSpec (DedicatedResources בלבד).
  • צריך לציין את כל השדות שרוצים לעדכן ב-updateMask. המערכת מתעלמת משדות שלא מופיעים ברשימה.
  • ה-DeployedModel חייב להיות במצב DEPLOYED. יכולה להיות לכל היותר פעולת שינוי פעילה אחת לכל מודל שמוטמע.
  • ‫mutateDeployedModel מאפשרת גם להפעיל או להשבית את רישום היומן של מאגר התגים. מידע נוסף זמין במאמר בנושא רישום ביומן של הסקה אונליין.