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

בדף הזה מוסבר איך לקבל הסקת מסקנות באצווה מהמודלים המותאמים אישית שאומנו באמצעות מסוף 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.
  • הזמן הקצוב לטעינת מודל היסק (inference) אצווה מסתיים אחרי כ-40 דקות. אם מופיעה הודעת השגיאה הבאה, צריך להשתמש במודל קטן יותר להסקת מסקנות באצווה: Error: model server never became ready. Please validate that your model file or container configuration are valid.
  • יש תמיכה בחשבונות שירות בהתאמה אישית רק בשרת המודל, ולא בלקוח של הסקת מסקנות באצווה שמבצע פעולות קריאה וכתיבה של נתונים אל ומ-Cloud Storage ומ-BigQuery.

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

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

JSON Lines

משתמשים בקובץ 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, כפי שנדרש על ידי המטפל שמוגדר כברירת מחדל ב-TorchServe. פלטפורמת הסוכנים של Gemini Enterprise לא עוטפת את המופעים בשבילכם. לדוגמה:

{ "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 Platform קוראת כל מופע בקובצי TFRecord כקובץ בינארי, ואז מקודדת את המופע בקידוד base64 כאובייקט JSON עם מפתח יחיד בשם b64.

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

כל שאר הקונטיינרים

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

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

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

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

CSV

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

בדוגמה הבאה מוצג קובץ 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 Platform קוראת את התוכן של כל קובץ כקובץ בינארי, ואז מקודדת את המופע בקידוד 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. Agent Platform הופכת כל שורה מהטבלה למופע 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 מבצעת באופן אוטומטי חלוקה למחיצות של קלט BigQuery, רשימת קבצים ושורות JSON.

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

אם משתמשים בקלט TFRecord, צריך לוודא שמחלקים את הנתונים באופן ידני על ידי פיצול המופעים לקבצים קטנים יותר והעברת הקבצים לעבודה עם תבנית wildcard (לדוגמה, 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"
  }
}

הדגמה של אופן השימוש במסנני תכונות זמינה במחברת Custom model batch inference with feature filtering.

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

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

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

מסוף Google Cloud

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

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

כניסה לדף Batch predictions

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

  2. בקטע Define your batch prediction (הגדרת חיזוי אצווה), מבצעים את השלבים הבאים:

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

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

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

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

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

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

    6. מציינים את אפשרויות החישוב לעבודת ההסקה באצווה: Number of compute nodes (מספר צמתי החישוב), Machine type (סוג המכונה), ו(אופציונלית) Accelerator type (סוג המאיץ) ו-Accelerator count (מספר המאיצים).

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

    1. לוחצים על המתג כדי להפעיל את האפשרות הפעלת מעקב אחר המודל עבור התחזית הקבוצתית הזו.

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

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

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

    5. אופציונלי: בערוצי התראות, מוסיפים ערוצים של 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: [מזהה הפרויקט](/resource-manager/docs/creating-managing-projects#identifiers). .

  • ‫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 של ספרייה שבה רוצים ש-Agent Platform תשמור את הפלט.

  • ‫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

שומרים את גוף הבקשה בקובץ בשם 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

שומרים את גוף הבקשה בקובץ בשם 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. מידע נוסף מופיע ב מאמרי העזרה של Python API. 

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. שימו לב שמודלים של חיזוי לא תומכים בחשיבות התכונות, ולכן אי אפשר לכלול אותה בבקשות שלכם להסקת מסקנות באצווה.

חשיבות המאפיינים, שנקראת לפעמים שיוך מאפיינים, היא חלק מ- 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 חלקי שנייה אחת)) מעוגל ל-17 רפליקות.

ההמלצות האלה הן הנחיות כלליות בלבד. הם לא בהכרח מספקים תפוקה אופטימלית לכל מודל. הם לא מספקים הערכות מדויקות של זמן העיבוד והעלות. הם לא בהכרח משקפים את האיזון הטוב ביותר בין עלות לבין תפוקה בכל תרחיש. אפשר להשתמש בהם כנקודת התחלה סבירה ולשנות אותם לפי הצורך. כדי למדוד מאפיינים כמו קצב העברת הנתונים של המודל, מריצים את מחברת 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}}

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

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

  • שיתוף הזמנות
  • מכונות וירטואליות של Spot
  • Flex-start VMs

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

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

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

קובצי Notebook

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