קבלת מסקנות בקבוצות ממודל שאומן בהתאמה אישית

בדף הזה מוסבר איך לקבל הסקות באצווה מהמודלים המותאמים אישית שאומנו באמצעות מסוף Google Cloud או Agent Platform API.

כדי לשלוח בקשה להסקת מסקנות באצווה, צריך לציין מקור קלט ומיקום פלט, ב-Cloud Storage או ב-BigQuery, שבו Gemini Enterprise Agent Platform מאחסנת את תוצאות הסקת המסקנות באצווה.

מגבלות ודרישות

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

• כדי לצמצם את זמן העיבוד, מיקומי הקלט והפלט צריכים להיות באותו אזור או באותו מרחב רב-אזורי. לדוגמה, אם הקלט הוא ב-us-central1, הפלט יכול להיות ב-us-central1 או ב-US, אבל לא ב-europe-west4. למידע נוסף, קראו את המאמרים מיקומים ב-Cloud Storage ומיקומים ב-BigQuery.
• גם הקלט והפלט צריכים להיות באותו אזור או באותו אזור גיאוגרפי נרחב שכולל מספר אזורים כמו המודל.
• בניגוד להסקת מסקנות אונליין, משימות של הסקת מסקנות באצווה לא מותאמות לעומס באופן אוטומטי. מכיוון שכל נתוני הקלט ידועים מראש, המערכת מחלקת את הנתונים לכל רפליקה כשהמשימה מתחילה. המערכת משתמשת בפרמטר starting_replica_count. המערכת מתעלמת מהפרמטר max_replica_count.
• מודלים של BigQuery ML הם לא מודלים שעברו אימון בהתאמה אישית. עם זאת, אפשר להשתמש במידע שבדף הזה כדי לקבל הסקות באצווה ממודל BigQuery ML, בתנאים הבאים:
  • המודל של BigQuery ML צריך להיות רשום במרשם המודלים של Gemini Enterprise Agent Platform.
  • כדי להשתמש בטבלה ב-BigQuery כקלט, צריך להגדיר את InstanceConfig.instanceType לערך "object" באמצעות Agent Platform API.
• הזמן הקצוב לטעינת מודל היסק באצווה מסתיים אחרי כ-40 דקות. אם מופיעה הודעת השגיאה הבאה, צריך להשתמש במודל קטן יותר להסקת מסקנות באצווה: Error: model server never became ready. Please validate that your model file or container configuration are valid.
• אפשר להשתמש בחשבונות שירות בהתאמה אישית רק בשרת המודל, ולא בלקוח להסקת מסקנות באצווה שמבצע פעולות קריאה וכתיבה של נתונים אל Cloud Storage ו-BigQuery ומתוכם.

הדרישות לגבי נתוני הקלט

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

הערה: Gemini Enterprise Agent Platform ממירה את הקלט למופעי JSON לפני שהיא שולחת אותו למאגר ההסקה. חשוב לוודא שהקונטיינר מקבל מופעים כמו שמתואר בקטע דרישות לקונטיינרים בהתאמה אישית.

הערה: בקונטיינרים מוגדרים מראש של PyTorch, פלטפורמת Gemini Enterprise Agent עוטפת כל מופע בשדה data לפני שהיא שולחת אותו לקונטיינר. הסיבה לכך היא שמטפלי ברירת המחדל של TorchServe מצפים שכל מופע יהיה עטוף בשדה data.

שורות JSON

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

דוגמה 1

בדוגמה הבאה מוצג קובץ JSON Lines שבו כל שורה מכילה מערך:

[1, 2, 3, 4]
[5, 6, 7, 8]

זה מה שנשלח למאגר התגים בגוף של בקשת ה-HTTP:

כל שאר המאגרים

{"instances": [ [1, 2, 3, 4], [5, 6, 7, 8] ]}

קונטיינרים של PyTorch

{"instances": [
{ "data": [1, 2, 3, 4] },
{ "data": [5, 6, 7, 8] } ]}

דוגמה 2

בדוגמה הבאה מוצג קובץ JSON Lines שבו כל שורה מכילה אובייקט.

{ "values": [1, 2, 3, 4], "key": 1 }
{ "values": [5, 6, 7, 8], "key": 2 }

זה מה שנשלח לקונטיינר בגוף בקשת ה-HTTP. חשוב לזכור שגוף הבקשה נשלח לכל הקונטיינרים.

{"instances": [
  { "values": [1, 2, 3, 4], "key": 1 },
  { "values": [5, 6, 7, 8], "key": 2 }
]}

דוגמה 3

במאגרי נתונים מוכנים מראש של PyTorch, חשוב לוודא שכל מופע מוקף בשדה data, כפי שנדרש על ידי ה-handler שמוגדר כברירת מחדל ב-TorchServe. פלטפורמת Gemini Enterprise Agent לא מקיפה את המופעים בשבילכם. לדוגמה:

{ "data": { "values": [1, 2, 3, 4], "key": 1 } }
{ "data": { "values": [5, 6, 7, 8], "key": 2 } }

זה מה שנשלח למאגר ההסקה בגוף בקשת ה-HTTP:

{"instances": [
  { "data": { "values": [1, 2, 3, 4], "key": 1 } },
  { "data": { "values": [5, 6, 7, 8], "key": 2 } }
]}

TFRecord

שומרים את מופעי הקלט בפורמט TFRecord. אפשר גם לדחוס את קובצי ה-TFRecord באמצעות Gzip. מאחסנים את קובצי ה-TFRecord בקטגוריה של Cloud Storage.

פלטפורמת Agent קוראת כל מופע בקובצי TFRecord כקובץ בינארי, ואז מקודדת את המופע ב-base64 כאובייקט JSON עם מפתח יחיד בשם b64.

זה מה שנשלח למאגר התגים בגוף של בקשת ה-HTTP:

כל שאר המאגרים

{"instances": [
{ "b64": "b64EncodedASCIIString" },
{ "b64": "b64EncodedASCIIString" } ]}

קונטיינרים של PyTorch

{"instances": [ { "data": {"b64": "b64EncodedASCIIString" } }, { "data": {"b64": "b64EncodedASCIIString" } }
]}

חשוב לוודא שהמאגר יודע איך לפענח את המכונה.

CSV

מציינים מופע קלט אחד בכל שורה בקובץ CSV. השורה הראשונה חייבת להיות שורת כותרת. כל המחרוזות צריכות להיות מוקפות במירכאות כפולות ("). פלטפורמת Agent לא מקבלת ערכי תאים שמכילים שורות חדשות. ערכים ללא מירכאות נקראים כמספרי נקודה צפה.

בדוגמה הבאה מוצג קובץ CSV עם שני מופעי קלט:

"input1","input2","input3"
0.1,1.2,"cat1"
4.0,5.0,"cat2"

זה מה שנשלח למאגר התגים בגוף של בקשת ה-HTTP:

כל שאר המאגרים

{"instances": [ [0.1,1.2,"cat1"], [4.0,5.0,"cat2"] ]}

קונטיינרים של PyTorch

{"instances": [
{ "data": [0.1,1.2,"cat1"] },
{ "data": [4.0,5.0,"cat2"] } ]}

רשימת הקבצים

יוצרים קובץ טקסט שבו כל שורה היא ה-URI של Cloud Storage לקובץ. פלטפורמת Agent קוראת את התוכן של כל קובץ כקובץ בינארי, ואז מקודדת את המכונה ב-base64 כאובייקט JSON עם מפתח יחיד בשם b64.

אם אתם מתכננים להשתמש במסוף Google Cloud כדי לקבל הסקות באצווה, הדביקו את רשימת הקבצים ישירות במסוף Google Cloud . אחרת, שומרים את הרשימה בקטגוריה של Cloud Storage.

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

gs://path/to/image/image1.jpg
gs://path/to/image/image2.jpg

זה מה שנשלח למאגר התגים בגוף של בקשת ה-HTTP:

כל שאר המאגרים

{ "instances": [
{ "b64": "b64EncodedASCIIString" },
{ "b64": "b64EncodedASCIIString" } ]}

קונטיינרים של PyTorch

{ "instances": [ { "data": { "b64": "b64EncodedASCIIString" } }, { "data": { "b64": "b64EncodedASCIIString" } }
]}

חשוב לוודא שהמאגר יודע איך לפענח את המכונה.

BigQuery

מציינים טבלה ב-BigQuery בתור projectId.datasetId.tableId. פלטפורמת הסוכנים ממירה כל שורה מהטבלה למופע JSON.

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

עמודה 1	עמודה 2	עמודה 3
1.0	3.0	"Cat1"
2.0	4.0	"Cat2"

זה מה שנשלח למאגר התגים בגוף של בקשת ה-HTTP:

כל שאר המאגרים

{"instances": [ [1.0,3.0,"cat1"], [2.0,4.0,"cat2"] ]}

קונטיינרים של PyTorch

{"instances": [
{ "data": [1.0,3.0,"cat1"] },
{ "data": [2.0,4.0,"cat2"] } ]}

כך סוגי הנתונים של BigQuery מומרים ל-JSON:

סוג BigQuery	סוג JSON	ערך לדוגמה
String	String	"abc"
מספר שלם	מספר שלם	1
Float	Float	1.2
Numeric	Float	4925.000000000
בוליאני	בוליאני	TRUE
TimeStamp	String	"2019-01-01 23:59:59.999999+00:00"
תאריך	String	"2018-12-31"
שעה	String	"23:59:59.999999"
DateTime	String	"2019-01-01T00:00:00"
הקלטה	אובייקט	{ "A": 1,"B": 2}
סוג חוזר	Array[Type]	[1, 2]
רשומה בתצוגת עץ	אובייקט	{"A": {"a": 0}, "B": 1}

נתוני חלוקה למחיצות

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

פלטפורמת Gemini Enterprise Agent Platform מחלקת באופן אוטומטי את הקלט של BigQuery, רשימת הקבצים ושורות ה-JSON.

‫Gemini Enterprise Agent Platform לא מחלקת קובצי CSV באופן אוטומטי כי הם לא מתאימים לחלוקה. שורות בקובצי CSV לא מתארות את עצמן, לא מוקלדות ויכולות להכיל שורות חדשות. אנחנו ממליצים לא להשתמש בקלט CSV באפליקציות שרגישות לקצב העברת הנתונים.

בקלט מסוג TFRecord, צריך לוודא שמחלקים את הנתונים באופן ידני על ידי פיצול המכונות לקבצים קטנים יותר והעברת הקבצים למשימה באמצעות תו כללי לחיפוש (לדוגמה, gs://my-bucket/*.tfrecord). מספר הקבצים צריך להיות לפחות כמספר הרפליקות שצוינו.

סינון וטרנספורמציה של נתוני הקלט

כדי לסנן ולשנות את קלט האצווה, מציינים את הערך instanceConfig בבקשה BatchPredictionJob.

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

טרנספורמציה מאפשרת לשלוח את המופעים לקונטיינר בפורמט JSON array או object. למידע נוסף, ראו instanceType.

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

customerId	col1	col2
1001	1	2
1002	5	6

ואתם מציינים את ה-instanceConfig הבא:

{
  "name": "batchJob1",
  ...
  "instanceConfig": {
    "excludedFields":["customerId"]
    "instanceType":"object"
  }
}

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

{"col1":1,"col2":2}
{"col1":5,"col2":6}

שימו לב שאם תציינו את ה-instanceConfig הבא, תקבלו את אותה תוצאה:

{
  "name": "batchJob1",
  ...
  "instanceConfig": {
    "includedFields": ["col1","col2"]
    "instanceType":"object"
  }
}

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

בקשה להסקת מסקנות באצווה

כדי לשלוח בקשות להסקת מסקנות באצווה, אתם יכולים להשתמש במסוף Google Cloud או ב-Agent Platform API. בהתאם למספר פריטי הקלט ששלחתם, יכול להיות שיעבור זמן מה עד שהמשימה של הסקת המסקנות באצווה תסתיים.

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

מסוף Google Cloud

משתמשים במסוף Google Cloud כדי לשלוח בקשה להסקה באצווה.

1. במסוף Google Cloud , בקטע Agent Platform, נכנסים לדף Batch predictions.

כניסה לדף Batch predictions

1. לוחצים על Create כדי לפתוח את החלון New batch prediction.

2. בקטע Define your batch prediction, מבצעים את השלבים הבאים:

   1. מזינים שם להסקת הנתונים באצווה.

   2. בשדה Model name, בוחרים את שם המודל שבו רוצים להשתמש להסקה באצווה.

   3. בקטע Select source, בוחרים את המקור שרלוונטי לנתוני הקלט:

      • אם הקלט הוא בפורמט JSON Lines,‏ CSV או TFRecord, בוחרים באפשרות File on Cloud Storage (JSON Lines, CSV, TFRecord, TFRecord Gzip). לאחר מכן מציינים את קובץ הקלט בשדה Source path.
      • אם אתם משתמשים ברשימת קבצים כקלט, בוחרים באפשרות Files on Cloud Storage (other)‎ ומדביקים את רשימת הקבצים בשדה הבא.
      • לקלט של BigQuery, בוחרים באפשרות BigQuery path. אם בוחרים ב-BigQuery כקלט, צריך גם לבחור ב-BigQuery כפלט ו- Google-managed encryption key. אין תמיכה במפתחות הצפנה בניהול הלקוח (CMEK) כשמשתמשים ב-BigQuery כקלט או כפלט.

   4. בשדה Destination path, מציינים את הספרייה ב-Cloud Storage שבה רוצים ש-Agent Platform ישמור את הפלט של הסקת המסקנות באצווה.

   5. אם רוצים לקבל שיוך (Attribution) של מאפיינים כחלק מהתגובה להסקת מסקנות באצווה, מסמנים את האפשרות Enable feature attributions for this model. אחר כך לוחצים על Edit כדי להגדיר את ההסברים. (אם כבר הגדרתם את ההסברים למודל, אתם לא חייבים לערוך את ההגדרות שלהם. אם לא הגדרתם אותם, אתם חייבים לערוך את ההגדרות).

   6. מציינים את אפשרויות המחשוב של משימת הסקת הנתונים באצווה: מספר צומתי המחשוב, סוג המכונה, ואם רוצים, גם סוג המאיץ ומספר המאיצים.

3. אופציונלי: ניתוח מעקב אחרי מודלים להסקת מסקנות באצווה זמין בגרסת טרום-השקה (Preview). הדרישות המוקדמות להוספת הגדרת זיהוי סטייה למשימת ההסקה באצווה.

   1. לוחצים על המתג Enable model monitoring for this batch prediction.

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

   3. אופציונלי: בקטע Alert thresholds, מציינים את ערכי הסף להפעלת התראות.

   4. בשדה Notification emails, מזינים כתובת אימייל אחת או יותר, מופרדות בפסיקים, כדי לקבל התראות באימייל כשמודל חורג מסף ההתראה.

   5. אופציונלי: בקטע Notification channels, מוסיפים ערוצים של Cloud Monitoring כדי לקבל התראות כשהמודל חורג מסף ההתראה. אפשר לבחור ערוצים קיימים ב-Cloud Monitoring או ליצור ערוץ חדש בלחיצה על Manage notification channels. במסוף Google Cloud יש תמיכה בערוצי ההתראות של PagerDuty,‏ Slack ו-Pub/Sub.

4. לוחצים על יצירה.

API

משתמשים ב-Agent Platform API כדי לשלוח בקשות להסקת מסקנות באצווה. בוחרים כרטיסייה בהתאם לכלי שבו משתמשים כדי לקבל הסקות באצווה.

REST

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

• ‫LOCATION_ID: האזור שבו המודל מאוחסן ושבו מופעלת משימת החיזוי באצווה. לדוגמה, us-central1.

• ‫PROJECT_ID: מזהה הפרויקט. .

• ‫BATCH_JOB_NAME: השם המוצג של משימת החיזוי באצווה.

• ‫MODEL_ID: המזהה של המודל שבו משתמשים כדי ליצור חיזויים.

• ‫INPUT_FORMAT: הפורמט של נתוני הקלט: jsonl,‏ csv,‏ tf-record,‏ tf-record-gzip או file-list.

• ‫INPUT_URI: ה-URI של Cloud Storage של נתוני הקלט. יכול להכיל תווים כלליים לחיפוש.

• ‫OUTPUT_DIRECTORY: ה-URI של Cloud Storage של הספרייה שבה רוצים שפלטפורמת הסוכנים תשמור את הפלט.

• ‫MACHINE_TYPE: משאבי המכונה שישמשו למשימת החיזוי באצווה.

  אפשר גם להגדיר את השדה machineSpec כדי להשתמש במאיצים, אבל הדוגמה הבאה לא מדגימה את זה.

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

• ‫STARTING_REPLICA_COUNT: מספר הצמתים של משימת החיזוי באצווה.

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

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/batchPredictionJobs

גוף בקשת JSON:

{
  "displayName": "BATCH_JOB_NAME",
  "model": "projects/PROJECT_ID/locations/LOCATION_ID/models/MODEL_ID",
  "inputConfig": {
    "instancesFormat": "INPUT_FORMAT",
    "gcsSource": {
      "uris": ["INPUT_URI"],
    },
  },
  "outputConfig": {
    "predictionsFormat": "jsonl",
    "gcsDestination": {
      "outputUriPrefix": "OUTPUT_DIRECTORY",
    },
  },
  "dedicatedResources" : {
    "machineSpec" : {
      "machineType": MACHINE_TYPE
    },
    "startingReplicaCount": STARTING_REPLICA_COUNT
  },
  "manualBatchTuningParameters": {
    "batch_size": BATCH_SIZE,
  }
}

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

curl

הערה: הפקודה הבאה מבוססת על ההנחה שנכנסתם ל-CLI של gcloud באמצעות חשבון המשתמש שלכם, על ידי הרצת gcloud init או gcloud auth login, או באמצעות Cloud Shell שמחבר אתכם אוטומטית ל-CLI של gcloud. כדי לבדוק איזה חשבון פעיל, אפשר להריץ את הפקודה gcloud auth list.

שומרים את גוף הבקשה בקובץ בשם request.json ומריצים את הפקודה הבאה:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/batchPredictionJobs"

PowerShell

הערה: הפקודה הבאה מבוססת על ההנחה שנכנסתם ל-CLI של gcloud באמצעות חשבון המשתמש שלכם, על ידי הרצת gcloud init או gcloud auth login. כדי לבדוק איזה חשבון פעיל, אפשר להריץ את הפקודה gcloud auth list.

שומרים את גוף הבקשה בקובץ בשם request.json ומריצים את הפקודה הבאה:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/batchPredictionJobs" | Select-Object -Expand Content

אתם אמורים לקבל תגובת JSON שדומה לזו:

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION_ID/batchPredictionJobs/BATCH_JOB_ID",
  "displayName": "BATCH_JOB_NAME 202005291958",
  "model": "projects/PROJECT_ID/locations/LOCATION_ID/models/MODEL_ID",
  "inputConfig": {
    "instancesFormat": "jsonl",
    "gcsSource": {
      "uris": [
        "INPUT_URI"
      ]
    }
  },
  "outputConfig": {
    "predictionsFormat": "jsonl",
    "gcsDestination": {
      "outputUriPrefix": "OUTPUT_DIRECTORY"
    }
  },
  "state": "JOB_STATE_PENDING",
  "createTime": "2020-05-30T02:58:44.341643Z",
  "updateTime": "2020-05-30T02:58:44.341643Z",
}

Java

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי הוראות ההגדרה של Java שמפורטות במאמר התחלה מהירה של Agent Platform באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של Agent Platform Java API.

כדי לבצע אימות ב-Agent Platform, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית.

בדוגמה הבאה, מחליפים את PREDICTIONS_FORMAT ב-jsonl. כדי ללמוד איך להחליף את ה-placeholders האחרים, עיינו בכרטיסייה REST & CMD LINE בקטע הזה.

import com.google.cloud.aiplatform.util.ValueConverter;
import com.google.cloud.aiplatform.v1.AcceleratorType;
import com.google.cloud.aiplatform.v1.BatchDedicatedResources;
import com.google.cloud.aiplatform.v1.BatchPredictionJob;
import com.google.cloud.aiplatform.v1.GcsDestination;
import com.google.cloud.aiplatform.v1.GcsSource;
import com.google.cloud.aiplatform.v1.JobServiceClient;
import com.google.cloud.aiplatform.v1.JobServiceSettings;
import com.google.cloud.aiplatform.v1.LocationName;
import com.google.cloud.aiplatform.v1.MachineSpec;
import com.google.cloud.aiplatform.v1.ModelName;
import com.google.protobuf.Value;
import java.io.IOException;

public class CreateBatchPredictionJobSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "PROJECT";
    String displayName = "DISPLAY_NAME";
    String modelName = "MODEL_NAME";
    String instancesFormat = "INSTANCES_FORMAT";
    String gcsSourceUri = "GCS_SOURCE_URI";
    String predictionsFormat = "PREDICTIONS_FORMAT";
    String gcsDestinationOutputUriPrefix = "GCS_DESTINATION_OUTPUT_URI_PREFIX";
    createBatchPredictionJobSample(
        project,
        displayName,
        modelName,
        instancesFormat,
        gcsSourceUri,
        predictionsFormat,
        gcsDestinationOutputUriPrefix);
  }

  static void createBatchPredictionJobSample(
      String project,
      String displayName,
      String model,
      String instancesFormat,
      String gcsSourceUri,
      String predictionsFormat,
      String gcsDestinationOutputUriPrefix)
      throws IOException {
    JobServiceSettings settings =
        JobServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();
    String location = "us-central1";

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (JobServiceClient client = JobServiceClient.create(settings)) {

      // Passing in an empty Value object for model parameters
      Value modelParameters = ValueConverter.EMPTY_VALUE;

      GcsSource gcsSource = GcsSource.newBuilder().addUris(gcsSourceUri).build();
      BatchPredictionJob.InputConfig inputConfig =
          BatchPredictionJob.InputConfig.newBuilder()
              .setInstancesFormat(instancesFormat)
              .setGcsSource(gcsSource)
              .build();
      GcsDestination gcsDestination =
          GcsDestination.newBuilder().setOutputUriPrefix(gcsDestinationOutputUriPrefix).build();
      BatchPredictionJob.OutputConfig outputConfig =
          BatchPredictionJob.OutputConfig.newBuilder()
              .setPredictionsFormat(predictionsFormat)
              .setGcsDestination(gcsDestination)
              .build();
      MachineSpec machineSpec =
          MachineSpec.newBuilder()
              .setMachineType("n1-standard-2")
              .setAcceleratorType(AcceleratorType.NVIDIA_TESLA_T4)
              .setAcceleratorCount(1)
              .build();
      BatchDedicatedResources dedicatedResources =
          BatchDedicatedResources.newBuilder()
              .setMachineSpec(machineSpec)
              .setStartingReplicaCount(1)
              .setMaxReplicaCount(1)
              .build();
      String modelName = ModelName.of(project, location, model).toString();
      BatchPredictionJob batchPredictionJob =
          BatchPredictionJob.newBuilder()
              .setDisplayName(displayName)
              .setModel(modelName)
              .setModelParameters(modelParameters)
              .setInputConfig(inputConfig)
              .setOutputConfig(outputConfig)
              .setDedicatedResources(dedicatedResources)
              .build();
      LocationName parent = LocationName.of(project, location);
      BatchPredictionJob response = client.createBatchPredictionJob(parent, batchPredictionJob);
      System.out.format("response: %s\n", response);
      System.out.format("\tName: %s\n", response.getName());
    }
  }
}

Python

במאמר התקנת Vertex AI SDK ל-Python מוסבר איך להתקין או לעדכן את Vertex AI SDK ל-Python. מידע נוסף מופיע ב מאמרי העזרה של ה-API מבוסס-Python.

def create_batch_prediction_job_dedicated_resources_sample(
    project: str,
    location: str,
    model_resource_name: str,
    job_display_name: str,
    gcs_source: Union[str, Sequence[str]],
    gcs_destination: str,
    instances_format: str = "jsonl",
    machine_type: str = "n1-standard-2",
    accelerator_count: int = 1,
    accelerator_type: Union[str, aiplatform_v1.AcceleratorType] = "NVIDIA_TESLA_K80",
    starting_replica_count: int = 1,
    sync: bool = True,
):
    aiplatform.init(project=project, location=location)

    my_model = aiplatform.Model(model_resource_name)

    batch_prediction_job = my_model.batch_predict(
        job_display_name=job_display_name,
        gcs_source=gcs_source,
        gcs_destination_prefix=gcs_destination,
        instances_format=instances_format,
        machine_type=machine_type,
        accelerator_count=accelerator_count,
        accelerator_type=accelerator_type,
        starting_replica_count=starting_replica_count,
        sync=sync,
    )

    batch_prediction_job.wait()

    print(batch_prediction_job.display_name)
    print(batch_prediction_job.resource_name)
    print(batch_prediction_job.state)
    return batch_prediction_job

BigQuery

בדוגמה הקודמת של REST, המקור והיעד הם Cloud Storage. כדי להשתמש ב-BigQuery, צריך לבצע את השינויים הבאים:

• משנים את השדה inputConfig לערך הבא:

  "inputConfig": {
     "instancesFormat": "bigquery",
     "bigquerySource": {
        "inputUri": "bq://SOURCE_PROJECT_ID.SOURCE_DATASET_NAME.SOURCE_TABLE_NAME"
     }
  }
  

• משנים את השדה outputConfig לערך הבא:

  "outputConfig": {
     "predictionsFormat":"bigquery",
     "bigqueryDestination":{
        "outputUri": "bq://DESTINATION_PROJECT_ID.DESTINATION_DATASET_NAME.DESTINATION_TABLE_NAME"
     }
   }
  

• מחליפים את מה שכתוב בשדות הבאים:

  • ‫SOURCE_PROJECT_ID: המזהה של פרויקט המקור Google Cloud
  • ‫SOURCE_DATASET_NAME: השם של מערך הנתונים המקורי ב-BigQuery
  • ‫SOURCE_TABLE_NAME: השם של טבלת המקור ב-BigQuery
  • ‫DESTINATION_PROJECT_ID: המזהה של פרויקט היעד ב- Google Cloud
  • ‫DESTINATION_DATASET_NAME: השם של מערך הנתונים ב-BigQuery שאליו מייצאים את הנתונים
  • ‫DESTINATION_TABLE_NAME: השם של טבלת היעד ב-BigQuery

חשיבות התכונה

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

חשיבות המאפיינים, שלפעמים נקראת שיוך (Attribution) של מאפיינים, היא חלק מ- Vertex AI ניתן להסברה.

אפשר להגדיר את generateExplanation ל-true רק אם הגדרתם את Model להסברים או אם ציינתם את השדה explanationSpec של BatchPredictionJob.

בחירת סוג המכונה ומספר הרפליקות

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

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

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

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

N / (T * (60 / Tb))

כאשר:

• ‫N: מספר האצוות במשימה. לדוגמה, מיליון מופעים חלקי גודל אצווה של 100 שווה ל-10,000 אצוות.
• ‫T: הזמן הצפוי למשימת ההסקה באצווה. לדוגמה, 10 דקות.
• ‫Tb: הזמן בשניות שנדרש לרפליקה כדי לעבד אצווה אחת. לדוגמה, שנייה אחת לכל אצווה במכונה עם 2 ליבות.

בדוגמה שלנו, 10,000 אצוות / (10 דקות * (60 / 1s)) מעוגל כלפי מעלה ל-17 רפליקות.

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

למכונות עם האצת GPU או TPU

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

• יכול להיות שתצטרכו יותר מעבדים (CPU) ויחידות GPU (לדוגמה, לעיבוד מראש של נתונים).
• למכונות מסוג GPU לוקח יותר זמן להתחיל לפעול (10 דקות), לכן כדאי להגדיר זמנים ארוכים יותר (לדוגמה, לפחות 20 דקות במקום 10 דקות) למשימת ההסקה באצווה, כדי שחלק סביר מהזמן והעלות יוקדשו ליצירת הסקות.

אחזור תוצאות של הסקת מסקנות באצווה

כשהמשימה של הסקת המסקנות באצווה מסתיימת, הפלט של הסקת המסקנות נשמר בקטגוריה של Cloud Storage או במיקום ב-BigQuery שציינתם בבקשה.

דוגמה לתוצאה של הסקת אצווה

תיקיית הפלט מכילה קבוצה של קובצי JSON Lines.

שמות הקבצים הם {gcs_path}/prediction.results-{file_number}-of-{number_of_files_generated}. מספר הקבצים לא דטרמיניסטי, בגלל האופי המבוזר של הסקת אצווה.

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

• ‫prediction: מכיל את הערך שהוחזר על ידי מאגר התגים.
• ‫instance: ברשימת קבצים, מכיל את ה-URI של Cloud Storage. בכל פורמט קלט אחר, המאפיין מכיל את הערך שנשלח לקונטיינר בגוף בקשת ה-HTTP.

דוגמה 1

אם בקשת ה-HTTP מכילה:

{
  "instances": [
    [1, 2, 3, 4],
    [5, 6, 7, 8]
]}

והמאגר מחזיר:

{
  "predictions": [
    [0.1,0.9],
    [0.7,0.3]
  ],
}

ואז קובץ הפלט של JSON Lines הוא:

{ "instance": [1, 2, 3, 4], "prediction": [0.1,0.9]}
{ "instance": [5, 6, 7, 8], "prediction": [0.7,0.3]}

דוגמה 2

אם בקשת ה-HTTP מכילה:

{
  "instances": [
    {"values": [1, 2, 3, 4], "key": 1},
    {"values": [5, 6, 7, 8], "key": 2}
]}

והמאגר מחזיר:

{
  "predictions": [
    {"result":1},
    {"result":0}
  ],
}

ואז קובץ הפלט של JSON Lines הוא:

{ "instance": {"values": [1, 2, 3, 4], "key": 1}, "prediction": {"result":1}}
{ "instance": {"values": [5, 6, 7, 8], "key": 2}, "prediction": {"result":0}}

נקודת קצה שגלויה למשתמשים

גרסת טרום-השקה (Preview) – נקודות קצה (endpoints) גלויות למשתמשים להסקת אצווה

השימוש בתכונה הזו כפוף לתנאי השימוש במוצרים בשלב טרום-GA, בחלק "תנאים כלליים לשירות" של התנאים הספציפיים לשירות. השימוש בתכונות בגרסת טרום-GA הוא "כפי שהן" (As is), ויכול להיות שהתמיכה בהן תהיה מוגבלת. אתם יכולים לקרוא מידע נוסף בקטע תיאור שלבי ההשקה.

כדי לשפר את יכולת הצפייה ולצמצם את מספר המכסות שצריך לנהל, שרת המודל זמין כנקודת קצה (endpoint) של Agent Platform שגלויה למשתמשים. אם תגדירו אחת מהתכונות הבאות, המודל ייפרס בנקודת קצה שגלויה למשתמשים:

• הזמנות משותפות
• ‏VMs במודל Spot
• מכונות וירטואליות מסוג Flex-start

שימוש ב-AI ניתן להסברה

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

הסקה באצווה לא תומכת בהסברים מבוססי-דוגמאות.

קובצי Notebook

כדי לקבל מידע נוסף, הריצו את ה-notebook‏ "Custom model batch prediction with feature filtering" באחת מהסביבות הבאות:

פתיחה ב-Colab | פתיחה ב-Colab Enterprise | פתיחה ב-Agent Platform Workbench | הצגה ב-GitHub

המאמרים הבאים

• מידע על משאבי המחשוב להסקה
• איך משתמשים בהזמנות עם הסקת מסקנות באצווה ב-Agent Platform