מעבר מ-Vertex AI Feature Store (הגרסה הקודמת) אל Bigtable

העברת עומס עבודה של ניהול תכונות למידת מכונה מ-Vertex AI Feature Store (גרסה קודמת) ל-Bigtable יכולה לשפר את הביצועים ואת הגמישות. במדריך הזה מופיעה סקירה כללית של מושגים קשורים ותהליך ההעברה.

‫Vertex AI Feature Store (מאגר תכונות מדור קודם) היא סביבה מנוהלת שמשתמשת ב-Bigtable כשכבת ההגשה אונליין. הפעלת פלטפורמת ה-AI או מאגר התכונות ישירות ב-Bigtable בלי להשתמש ב-Vertex AI Feature Store (מהדור הקודם) יכולה להוביל למהירויות גבוהות יותר ולעלויות נמוכות יותר.

אנחנו ממליצים על נתיב העברה מינימלי שמתמקד בהעברת נתונים מטבלאות Bigtable הבסיסיות ב-Vertex AI Feature Store (גרסה קודמת) למופע Bigtable שאתם יוצרים בפרויקט Google Cloud .

היתרונות של ההעברה

למעבר ל-Bigtable יש כמה יתרונות אסטרטגיים ותפעוליים:

מושגים מרכזיים

בקטע הזה מתואר איך מושגי הליבה של Vertex AI Feature Store (גרסה קודמת) מיושמים ב-Bigtable וב-BigQuery.

שמירת נתונים

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

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

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

פיתוח תכונות

ב-Bigtable, אפשר להטמיע פיתוח תכונות אונליין באמצעות Bigtable SQL, ואפשר להטמיע פיתוח תכונות אופליין באמצעות BigQuery DataFrames.

כשמשתמשים ב-Vertex AI Feature Store (גרסה קודמת), עובדים עם ממשקי API למפתחים ומודלים של נתונים שממופים למקורות נתונים בסיסיים שהוכנו ב-BigQuery. לאחר מכן רושמים את מקורות הנתונים האלה ואת עמודות המאפיינים הספציפיות במאגר המאפיינים. כשמשתמשים במאגר תכונות של Bigtable, עובדים ישירות עם נתונים במופעי BigQuery ו-Bigtable הבסיסיים, בלי צורך למפות למודל הנתונים של Vertex AI Feature Store (Legacy).

פיתוח תכונות אונליין

לפיתוח תכונות באינטרנט, Bigtable מציע כמה כלים:

  • ספריית לקוח Python: אפשר להשתמש בספריית הלקוח של Python ל-Bigtable כדי לעבוד ישירות עם נתונים ב-Bigtable.
  • ‫GoogleSQL: אפשר להשתמש ב-GoogleSQL כדי לקרוא ולשנות נתונים ב-Bigtable. אפשר להריץ שאילתות SQL ישירות במסוף Bigtable או מספריית הלקוח של Python.
  • תצוגות חומריות מתמשכות: כדי ליצור תכונות כמעט בזמן אמת שדורשות טרנספורמציות וצבירות חוזרות, אפשר להשתמש בתצוגות חומריות מתמשכות של Bigtable כדי להריץ בהדרגה שאילתת SQL על נתונים כשהם מגיעים ל-Bigtable.

פיתוח תכונות אופליין

לפיתוח תכונות אופליין, BigQuery DataFrames מספק ממשק Python עם יותר מ-750 ממשקי API של pandas ו-scikit-learn. ממשקי ה-API האלה מיושמים באמצעות המרת SQL ל-BigQuery ול-BigQuery ML APIs. התכונה BigQuery DataFrames מאפשרת ליצור פונקציות Python מובנות וגם פונקציות מוגדרות על ידי המשתמש. בנוסף, הוא מספק סנכרון נתונים אוטומטי עם Bigtable כדי להציג תכונות שנוצרו בתהליכי אצווה ואופליין, כפי שמתואר בקטע הבא.

סנכרון תכונות אונליין ואופליין

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

  • סנכרון באצווה: תהליך Reverse ETL מ-BigQuery אל Bigtable מאפשר לייצא את התוצאות של שאילתת BigQuery אל Bigtable. השאילתות האלה מורצות באצווה ואפשר לתזמן אותן ישירות מ-BigQuery.
  • סנכרון בסטרימינג: שאילתות רציפות ב-BigQuery הן הצהרות SQL שפועלות באופן רציף ומפיקות שורות לטבלת Bigtable.
  • סנכרון מ-BigQuery DataFrames: כדי לתעד תכונות אופליין שפותחו ב-Python, אפשר להשתמש ב-BigFrames StreamingDataFrame כדי ליצור שאילתה רציפה ב-BigQuery שתתעד את הלוגיקה של Python ליצירת תכונות ותסנכרן את תוצאות הנתונים עם Bigtable.
  • פיתוח תכונות אופליין ישירות על נתוני Bigtable: אפשר ליצור תכונות אופליין ב-BigQuery על סמך נתונים שמאוחסנים ב-Bigtable באמצעות טבלה חיצונית של BigQuery. טבלה חיצונית משקפת את המראה של טבלה ב-BigQuery ומציעה את רוב הפונקציונליות שלה, כמו שאילתות איחוד (join), שאילתות מתוזמנות ופונקציות מתקדמות של BigQuery SQL, בלי הצורך להעביר נתונים בחזרה לאחסון ב-BigQuery. כדי לא להשפיע על התנועה של האפליקציה, אפשר להשתמש במחשוב ללא שרת של Data Boost כשקוראים נתונים של Bigtable באמצעות טבלאות חיצוניות של BigQuery. השימוש ב-Data Boost משתלם במיוחד בשאילתות אד-הוק. כדי להשתמש ב-Data Boost, צריך לציין פרופיל אפליקציה של Data Boost כשיוצרים את הגדרת הטבלה החיצונית. מידע נוסף על Data Boost זמין במאמר סקירה כללית על Data Boost ב-Bigtable.

אחרי ההעברה, תוכלו להמשיך להשתמש ב-Vertex AI Model Monitoring כדי לעקוב אחרי איכות המודלים.

השימוש ב-Bigtable וב-BigQuery ביחד הוא דפוס נפוץ לבניית מסדי נתונים לניתוח בזמן אמת.

שלבי ההעברה

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

שלב 1: הכנת התשתית

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

שלב 2: הגדרת מיפוי הסכימה בין Vertex AI Feature Store (גרסה קודמת) לבין Bigtable

  1. קוראים את השיטות המומלצות לתכנון סכימה ב-Bigtable ומוודאים שכל סעיפיה מובנים לכם. מיפוי כללי של Vertex AI Feature Store (Legacy) API ל-Bigtable API:

    משאב Vertex AI Feature Store (גרסה קודמת)

    רכיב Bigtable

    FeatureOnlineStore

    מכונת Bigtable

    FeatureView

    קבוצת עמודות

    featureValues (batch)

    עמודה (תא יחיד לכל מפתח)

    featureValues (מתמשך)

    עמודה (תאים מרובים לכל מפתח [ניהול גרסאות])

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

שלב 3: חילוץ נתונים וסינכרון

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

סנכרון תכונות בזמן אמת

אם אתם כותבים תכונות באמצעות write_feature_values או קריאות API מקבילות, התחילו לכתוב את אותם נתונים לטבלת Bigtable החדשה.

  1. מתקינים את ספריית הלקוח של Python ל-Bigtable.
  2. מגדירים את האפליקציה כך שתכתוב נתוני תכונות בו-זמנית אל Vertex AI Feature Store (מאגר תכונות מדור קודם) ואל Bigtable. למידע נוסף על כתיבת נתונים ל-Bigtable, ראו כתיבה.

העברה של תכונות באצווה

לאחר מכן, מעבירים את הנתונים שנשמרו לפני שהתחלתם להשתמש בכתיבה כפולה. התהליך כולל העברת הנתונים מ-Vertex AI Feature Store (גרסה קודמת) אל BigQuery ואז אל Bigtable.

  1. אפשר לייצא נתונים ממאגר התכונות ל-BigQuery באמצעות יכולות הייצוא של Vertex AI Feature Store (מאגר תכונות מדור קודם), שמאפשרות לייצא את כל הערכים או תמונות מצב. כך אפשר להשתמש ב-BigQuery כמאגר הנתונים הלא מקוון של Vertex AI Feature Store (גרסה קודמת).
  2. מעבירים את הנתונים ההיסטוריים מ-BigQuery ל-Bigtable באחת מהדרכים הבאות:

שלב 4: מעבר של האפליקציה ושל ה-SDK

השלב האחרון הוא מעבר לשכבת האפליקציה.

  1. אחרי שהמיגרציה מסתיימת ונבדקת, מפסיקים לכתוב אל Vertex AI Feature Store (Legacy).

  2. משנים את האפליקציה כך שתשתמש רק בספריית הלקוח של Python ל-Bigtable.

    בדוגמה הבאה מוצג שימוש ב-Python כדי לשלוף תכונה יחידה מ-Bigtable.

    from google.cloud import bigtable
from google.cloud.bigtable import row_filters
# Replace 'project_id' and 'instance_id' with your actual IDs.
client = bigtable.Client(project=project_id)
instance = client.instance(instance_id)

#return only the latest feature
row_filter = bigtable.row_filters.CellsColumnLimitFilter(1)

# Replace 'user1' and 'feature0` with your actual row key and column qualifier.

print("Getting a single feature by row key.")
key = "user1".encode()

row = table.read_row(key, row_filter)
cell = row.cells[column_family_id.decode("utf-8")][feature0][0]
print(cell.value.decode("utf-8"))

    דוגמה נוספת לקריאה וכתיבה של נתונים באמצעות Bigtable Data API ו-Admin API זמינה במאמר Python hello world.

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

    import asyncio
from google.cloud.bigtable.data_async import BigtableDataClient
from google.cloud.bigtable_v2.types import ExecuteQueryRequest

async def run_bigtable_sql_query(project_id, instance_id, table_id):
    """
    Runs a GoogleSQL query on a Bigtable table using the async client.
    """
    client = BigtableDataClient(project_id=project_id)
    instance = client.instance(instance_id)
    table = instance.table(table_id)

    # Example query: Select a specific row and all columns from a column family
    # Replace 'my_table' and 'my_cf' with your actual table and column family IDs.
    # The table name in the SQL must be in the format `dataset.table`,
    # where dataset is the instance ID and table is the table ID (in backticks).
    sql_query = f"SELECT _key, my_cf FROM `{instance_id}`.`{table_id}` WHERE _key = 'user_123'"

    print(f"Executing query: {sql_query}")

    # The client library automatically handles the SQL execution
    try:
        # The query method returns an AsyncPartialRowsIterator
        results_iterator = await table.query(query=sql_query)

        async for row in results_iterator:
            print(f"Row key: {row.row_key.decode('utf-8')}")
            # Iterate through the cells in the row
            for col_family, cells in row.cells.items():
                for cell in cells:
                    print(f"  Column Family: {col_family}, Qualifier: {cell.qualifier.decode('utf-8')}, Value: {cell.value.decode('utf-8')}, Timestamp: {cell.timestamp_micros}")

    except Exception as e:
        print(f"An error occurred: {e}")
    finally:
        await client.close()

if __name__ == "__main__":
    # TODO(developer): Replace with your project, instance, and table IDs
    your_project_id = "your-gcp-project-id"
    your_instance_id = "your-bigtable-instance-id"
    your_table_id = "your-bigtable-table-id"

    # Run the asynchronous function
    asyncio.run(run_bigtable_sql_query(your_project_id, your_instance_id, your_table_id))

  3. להתחיל להשתמש במדדים של Bigtable כדי לעקוב אחרי זמן האחזור וקצב העברת הנתונים. מידע נוסף זמין במאמר בנושא Monitoring.

שיטות מומלצות

אחרי שעוברים מ-Vertex AI Feature Store (גרסה קודמת) להטמעה של חנות תכונות ב-Bigtable, צריך לשכפל את הלוגיקה הפנימית של העיבוד המקדים והאופטימיזציה שטופלה בעבר על ידי השירות, כדי לשמור על יציבות ועל ביצועים.

הגבלת קצב דינמית בצד הלקוח

הקצה העורפי של Vertex AI Feature Store (גרסה קודמת) משתמש במנגנון לוויסות תעבורה (throttling) אדפטיבי בצד הלקוח כדי להגן על מופעי Bigtable הבסיסיים מפני עומס יתר במהלך עליות פתאומיות בתעבורה או כשהקצה העורפי של האחסון חווה זמן אחזור גבוה או שגיאות. מומלץ להטמיע מנגנון דומה להגבלת קצב הבקשות בקוד של האפליקציה כדי לרשום תגובות מהקצה העורפי ולהגביל באופן יזום את קצב הבקשות כשצריך.

בקשה לאופטימיזציה של חלוקה למחיצות וגודל אצווה

יש מגבלה קשיחה של 20KB על פילטרים של שורות ב-Bigtable. בקשה של יותר מדי תכונות או מזהי ישויות בקריאה מסוננת אחת עלולה לגרום לכשל בבקשות. כדי לשקף את ההתנהגות של Vertex AI Feature Store (גרסה קודמת), צריך לבצע את הפעולות הבאות:

  • מזהי תכונות של חלקי נתונים: מגבילים את מספר מזהי התכונות לכל קריאה של Bigtable לכ-100.
  • אצווה של ישויות מאזן: כדי למנוע עומס על משאבי הלקוח או השרת כשמבצעים קריאות של כמה ישויות, צריך לנקוט באמצעי הזהירות הבאים:
    • לחלק את הישויות לקבוצות קטנות בו-זמנית, למשל 10 ישויות בכל קבוצה.
    • הגבלת המספר המקסימלי של בקשות אצווה בו-זמניות, למשל 10-20.

בחירה חכמה של מסננים

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

בו-זמניות (concurrency) וביצוע אסינכרוני

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

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