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

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

הסבר על הטמעות וקטורים אוטומטיות

הטמעות וקטורים אוטומטיות ב-AlloyDB מספקות דרך ניתנת להתאמה לאוטומציה של היצירה והתחזוקה של הטמעות וקטורים לנתונים שלכם. במקום ליצור הטמעות באופן ידני לכל טקסט חדש או מעודכן, אתם יכולים להגדיר הטמעות וקטורים אוטומטיות שיטפלו בתהליך הזה בשבילכם. האפשרות הזו שימושית במיוחד לאפליקציות שמסתמכות על הטמעות עדכניות לצורך חיפוש סמנטי, Retrieval-Augmented Generation (יצירה משולבת-אחזור, RAG) ותכונות AI אחרות.

בעזרת הטמעות וקטורים אוטומטיות, אתם יכולים:

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

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

מודלים נתמכים

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

  • הטמעות רשומות מראש של Google: מודלים רשומים מראש של Google, כמו text-embedding-005 ו-gemini-embedding-001. אתם יכולים להשתמש במודלים האלה בלי להירשם. מידע נוסף מופיע במאמר מודלים רשומים מראש של Gemini Enterprise Agent Platform.
  • מודלים של צד שלישי שמתארחים אצל ספקים חיצוניים: מודלים של הטמעה שמתארחים אצל ספקים של צד שלישי, כמו text-embedding-3-small או text-embedding-3-large של OpenAI. כדי להשתמש במודלים האלה, צריך לרשום את נקודת הקצה של המודל באמצעות ניהול נקודות הקצה של המודלים. מידע נוסף זמין במאמר מודל הטמעת טקסט של OpenAI.
  • מודלים בהתאמה אישית שמתארחים באופן מקומי או מרחוק: מודלים באירוח עצמי, מודלים שמתארחים באופן מקומי בתשתית פרטית או מודלים שמתארחים מאחורי נקודות קצה בהתאמה אישית. כדי להשתמש במודלים בהתאמה אישית עם הטמעות וקטורים אוטומטיות, צריך להגדיר פונקציות טרנספורמציה ולרשום את נקודת הקצה של המודל באמצעות ניהול נקודות הקצה של המודל. מידע נוסף זמין במאמר מודל הטמעת טקסט באירוח בצד הלקוח.

לפני שמתחילים

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

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

    כדי לבדוק ולהגדיל את המכסות:

    1. נכנסים לדף Quotas במסוף Google Cloud .
    2. מסננים לפי המדדים הבאים שרלוונטיים למודל ולאזור שלכם:
      • בקשות לדקה (RPM): Regional online prediction requests per base model per minute per region per base_model
      • לגבי טוקנים של Gemini: ‏Embed content input tokens per minute per region per base_model
    3. אם המגבלות הנוכחיות לא מספיקות לגודל הטבלה, מאתרים את ערך המכסה שרוצים לעדכן ומסמנים את התיבה שליד המכסה.
    4. לוחצים על Edit. תיבת הדו-שיח Quota changes נפתחת.

      איך שולחים בקשה לשינוי המכסות

    במכסות ובמגבלות של Agent Platform מפורטות המגבלות של מודל ההטמעה ב-Agent Platform ורשימה מלאה של המכסות.

  • מתחברים למסד הנתונים באמצעות psql או AlloyDB Studio בתור המשתמש postgres.

  • מוודאים שהתוסף google_ml_integration מותקן ושהגרסה שלו היא 1.5.6 ומעלה.

  • מוודאים שהדגלים google_ml_integration.enable_model_support ו-google_ml_integration.enable_faster_embedding_generation מוגדרים לערך on.

  • אם אתם משתמשים בהטמעות של Google, אתם צריכים להגדיר את AlloyDB כך שיעבוד עם Agent Platform. מידע נוסף זמין במאמר שילוב מסד הנתונים עם Agent Platform.

  • אם אתם משתמשים במודלים של הטמעות בהתאמה אישית או של צד שלישי, רשמו את נקודת הקצה של המודל באמצעות ניהול נקודות הקצה של המודל לפני ההפעלה של הטמעות וקטורים אוטומטיות.

  • כדי לנהל ולנטר את יצירת ההטמעות האוטומטיות, למשתמשים יש גישת Select לטבלאות google_ml.embed_gen_progress ו-google_ml.embed_gen_settings כברירת מחדל.

    כדי לאפשר למשתמש לנהל את היצירה האוטומטית של הטמעות, צריך לתת את ההרשאות INSERT,‏ UPDATE ו-DELETE בטבלאות google_ml.embed_gen_progress ו-google_ml.embed_gen_settings:

    GRANT INSERT, UPDATE, DELETE ON google_ml.embed_gen_progress TO "USER_NAME";
    

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

    • ‫USER_NAME: שם המשתמש שקיבל את ההרשאות.
  • מסיימים את ההגדרה הראשונית שמתוארת במאמר יצירת הטמעות טקסט.

  • מוודאים שהערך של AUTOCOMMIT מוגדר כ-ON בלקוח PostgreSQL שבו משתמשים.

אימות גרסת התוסף

כדי לבדוק את הגרסה של התוסף google_ml_integration, מריצים את הפקודה הבאה:

SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';

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

ALTER EXTENSION google_ml_integration UPDATE;

מוודאים שהדגלים לניהול מסד הנתונים מוגדרים לערך on

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

SHOW google_ml_integration.enable_model_support;
SHOW google_ml_integration.enable_faster_embedding_generation;

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

הכנת הטבלה

כדי ליצור הטמעות אוטומטיות, צריך ליצור עמודה בטבלה שבה יישמרו הווקטורים שנוצרו. העמודה הזו בדרך כלל משתמשת בסוג vector(DIMENSION) וחייב להיות לה ערך DEFAULT NULL.

לדוגמה, כדי להוסיף עמודה של הטמעות עם 768 מאפיינים לטבלה בשם user_reviews:

ALTER TABLE user_reviews ADD COLUMN IF NOT EXISTS content_embeddings vector(768) DEFAULT NULL;

הפעלה של הטמעות בטבלה

הפונקציות לניהול הטמעות וקטורים אוטומטיות זמינות גם בסכימה ai וגם בסכימה google_ml. הסכימה ai מספקת ממשק פשוט לתכונות ה-AI העדכניות ביותר ב-AlloyDB.

משתמשים בפונקציית ה-SQL‏ ai.initialize_embeddings() כדי ליצור הטמעות לעמודת התוכן של הטבלה. זו קריאה חוסמת, כלומר הסשן של מסד הנתונים ממתין עד שהפעולה תושלם לפני שהוא מחזיר תוצאה ומאפשר לכם להנפיק פקודות חדשות בסשן הזה. עם זאת, חיבורים אחרים למסד הנתונים לא נחסמים ויכולים להמשיך לעבוד עם הטבלה:

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

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

יצירת קבוצת תמונות

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

גודל אצווה של רמזים

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

CALL ai.initialize_embeddings(
    model_id => 'text-embedding-005',
    table_name => 'user_reviews',
    content_column => 'content',
    embedding_column => 'content_embeddings',
    batch_size => 50
);

שימוש במודל הטמעה בהתאמה אישית עם תמיכה באצווה

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

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

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

    -- Scalar input transform functions
    CREATE OR REPLACE FUNCTION acme_text_input_transform(model_id TEXT, input TEXT) RETURNS JSON;
    CREATE OR REPLACE FUNCTION acme_text_output_transform(model_id TEXT, model_output JSON) RETURNS real[];
    CREATE OR REPLACE FUNCTION acme_generate_headers(model_id TEXT, input TEXT) RETURNS JSON;
    -- Batch input transform functions
    CREATE OR REPLACE FUNCTION acme_text_batch_input_transform(model_id TEXT, input TEXT[]) RETURNS JSON;
    CREATE OR REPLACE FUNCTION acme_text_batch_output_transform(model_id TEXT, model_output JSON) RETURNS real[][];
    
  2. כדי ליצור את המודל, מציינים את פונקציות הטרנספורמציה של ה-batch.

    CALL
      ai.create_model(
        model_id => 'custom-embedding-model',
        model_request_url => 'https://acme.com/models/text/embeddings/v1',
        model_type => 'text_embedding',
        model_in_transform_fn => 'acme_text_input_transform',
        model_out_transform_fn => 'acme_text_output_transform',
        generate_headers_fn => 'acme_generate_headers',
        model_batch_in_transform_fn => 'acme_text_batch_input_transform',
        model_batch_out_transform_fn => 'acme_text_batch_output_transform'
      );
    
  3. יוצרים הטמעות וקטורים באמצעות המודל בהתאמה אישית.

    CALL
      ai.initialize_embeddings(
        model_id => 'custom-embedding-model',
        table_name => 'user_reviews',
        content_column => 'content',
        embedding_column => 'content_embeddings',
        batch_size => 10
    );
    

אתם יכולים להשתמש בתכונה "הטמעה אוטומטית" גם במודלים בהתאמה אישית שלא תומכים באופן מובנה בהטמעה באצווה. כדי לעשות את זה, עדיין צריך להגדיר את פונקציות הטרנספורמציה באצווה model_batch_in_transform_fn ו-model_batch_out_transform_fn. במודל ללא אצווה, מגדירים את הפונקציות האלה כדי לעבד קלט אחד בכל פעם ממערך הקלט. כשמפעילים את ai.initialize_embeddings במודל הזה, צריך להגדיר את batch_size ל-1.

שימוש במאפיינים מותאמים אישית עם תמיכה באצווה

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

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

CREATE OR REPLACE FUNCTION google_ml.vertexai_text_embedding_batch_input_transform_with_768_dims(model_id VARCHAR(100), input_list TEXT[])
RETURNS JSON
LANGUAGE SQL
AS $$
  SELECT pg_catalog.json_build_object(
    'instances',
    pg_catalog.json_agg(pg_catalog.json_build_object('content', content)),
    'parameters',
    pg_catalog.json_build_object('outputDimensionality', 768)
  ) FROM unnest(input_list) AS content;
$$;

שימוש באופטימיזציה של JSONB עם מודלים בהתאמה אישית

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

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

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

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

CREATE OR REPLACE FUNCTION my_batch_output_transform(model_id TEXT, model_output JSON) RETURNS real[][];

כך יוצרים וריאנט של JSONB:

CREATE OR REPLACE FUNCTION my_batch_output_transform(model_id TEXT, model_output JSONB) RETURNS real[][];

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

רענון הדרגתי של הטמעות

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

כדי לתת לכם שליטה על העקביות והביצועים, AlloyDB תומך במצבים שונים של רענון הטמעות מצטבר. אפשר לבחור מצב באמצעות הארגומנט enum‏ incremental_refresh_mode ב-ai.initialize_embeddings(). אלה המצבים האפשריים:

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

    CALL
      ai.initialize_embeddings(
        model_id => 'text-embedding-005',
        table_name => 'user_reviews',
        content_column => 'content',
        embedding_column => 'content_embeddings',
        batch_size => 10,
        incremental_refresh_mode => 'transactional'
    );
    

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

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

  • ‫manual: זהו מצב ברירת המחדל. במצב הזה, נוספת לטבלה עמודת מעקב בוליאנית חדשה כדי לעקוב אחרי הטמעות לא עדכניות. כשקוראים לפונקציה ai.refresh_embeddings(), מתבצע רענון מצטבר תקופתי שיוצר הטמעות רק לשורות חדשות או מעודכנות. אנחנו ממליצים על המצב הזה למשתמשים שצריכים יותר שליטה על הביצועים, במיוחד כשמטפלים במספר גדול של הוספות או עדכונים אחרי הטעינה הראשונית. הוא שימושי בתרחישים שבהם חשוב לצמצם את זמן האחזור של הכתיבה, ושאפשר להשתמש בהם בהטמעות זמניות או ריקות עד שמופעל רענון מצטבר תקופתי באמצעות ai.refresh_embeddings. כדי לעדכן שורות ישנות או חדשות, משתמשים בפונקציה ai.refresh_embeddings() כמו שמתואר בקטע רענון כל ההטמעות בטבלה.

בחירת מצב רענון

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

מצב תיאור עקביות וביצועים למי זה מתאים
transactional המערכים המוטמעים מתעדכנים כחלק מהטרנזקציה של מסד הנתונים באמצעות מנגנון שדומה לטריגר. חשוב לדעת שהאפשרות ai.refresh_embeddings() מושבתת במצב הזה. עקביות מיידית. תקורה גבוהה של זמן אחזור בכתיבה, כי כל INSERT או UPDATE מפעילים יצירת הטמעה. הדגמות, מערכי נתונים קטנים או טבלאות שבהן עקביות הנתונים היא קריטית.
manual (ברירת מחדל) משתמש בעמודת מעקב בוליאנית כדי לעקוב אחרי שורות ישנות או חדשות. כדי להפעיל רענון מצטבר תקופתי, צריך לשלוח קריאה אל ai.refresh_embeddings(). מודל עקביות הדרגתי. זמן אחזור מינימלי של כתיבה, כי ההטמעות נוצרות בכמות גדולה בזמן שאתם בוחרים. קבוצות נתונים גדולות, סביבות ייצור עם תדירות כתיבה גבוהה או אפליקציות שרגישות לביצועים.

רענון כל ההטמעות בטבלה

אחרי שמריצים בהצלחה את ai.initialize_embeddings() בטבלה באמצעות מצב הרענון המצטבר manual, אפשר לבצע רענון מצטבר תקופתי של ההטמעות, שמופעל באמצעות ai.refresh_embeddings. אתם יכולים להשתמש בפעולת רענון כדי לעדכן הטמעות של שורות שמשתנות בו-זמנית במהלך הקריאה הראשונית ל-initialize_embeddings, או כדי לבצע רענון מצטבר תקופתי.

אם תהליך יצירת ההטמעה מופסק במצב ידני, למשל על ידי pg_cancel, צריך להפעיל את הפונקציה ai.refresh_embeddings() כדי להשלים את היצירה של השורות שנותרו.

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

CALL ai.refresh_embeddings(
    table_name => 'user_reviews',
    embedding_column => 'content_embeddings',
    batch_size => 50  -- Optional override
);

עבודה עם נתוני טבלה במהלך יצירת הטמעת וקטורים

הפונקציה ai.initialize_embeddings() היא קריאה חוסמת לסשן שבו היא פועלת, אבל חיבורים אחרים יכולים להמשיך לעבוד עם הטבלה. תהליך הטמעת הווקטורים האוטומטי מעדכן שורות בקבוצות באמצעות נעילה רגילה ברמת השורה. המשמעות היא שפעולות בו-זמניות של שפת טיפול בנתונים (DML) – כמו UPDATE או DELETE – מחיבורים אחרים נחסמות רק לזמן קצר אם הן מנסות לשנות את אותן שורות שמטורגטות על ידי משימת ההטמעה הפעילה. שאילתות SELECT שלא משנות את הנתונים לא נחסמות.

מחיקת ההגדרות של הטמעת וקטורים אוטומטית

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

CALL
  ai.drop_embedding_config(
    table_name => 'user_reviews',
    embedding_column => 'content_embeddings');

עבודה עם טבלאות מחולקות למחיצות

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

הפעלת הטמעות בטבלה מחולקת למחיצות

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

CALL ai.initialize_embeddings(
    model_id => 'text-embedding-005',
    table_name => 'documents', -- This is the root partitioned table
    content_column => 'content',
    embedding_column => 'content_embeddings'
);

רענון של הטמעות בטבלה מחולקת למחיצות

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

  • כדי לרענן את כל הטבלה, מריצים את הפקודה הבאה:
CALL ai.refresh_embeddings(
    table_name => 'documents', -- This is the root partitioned table
    embedding_column => 'content_embeddings'
);
  • כדי לרענן מחיצה אחת, מריצים את הפקודה הבאה:
CALL ai.refresh_embeddings(
    table_name => 'documents_eu',
    embedding_column => 'content_embeddings'
);

רענון ההטמעות של מחיצות שנוספו או צורפו לאחרונה

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

  • מחיצה חדשה שנוספה: אם מוסיפים מחיצה חדשה לטבלה, אפשר ליצור לה הטמעות על ידי קריאה ל-ai.refresh_embeddings במחיצה החדשה.
-- Add a new partition
CREATE TABLE documents_africa PARTITION OF documents
    FOR VALUES IN ('africa');

-- Refresh embeddings for the new partition
CALL ai.refresh_embeddings(
    table_name => 'documents_africa',
    embedding_column => 'content_embeddings'
);
  • מחיצה שצורפה לאחרונה: כדי לצרף טבלה קיימת כמחיצה, קודם צריך להשתמש בפרוצדורה ai.embedding_prepare_partition כדי לוודא שהסכימה שלה תואמת לטבלה המחולקת למחיצות. תכונת ההטמעה האוטומטית תומכת בהוספה או בצירוף של מחיצות בכל רמה של הגדרת מחיצה היררכית. הפרוצדורה ai.embedding_prepare_partition מוודאת שהסכימה תואמת לכל טבלת הורה בהיררכיה.

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

-- Prepare the table to be attached
CALL ai.embedding_prepare_partition(
    parent_table => 'documents',
    child_table => 'documents_misc'
);

-- Attach the partition
ALTER TABLE documents ATTACH partition documents_misc DEFAULT;

-- Refresh embeddings for the newly attached partition
CALL ai.refresh_embeddings(
    table_name => 'documents_misc',
    embedding_column => 'content_embeddings'
);

תכונת ההטמעה האוטומטית תומכת בהוספה או בצירוף של מחיצות בכל רמה של הגדרת מחיצה היררכית. הפרוצדורה ai.embedding_prepare_partition מוודאת שהסכימה תואמת לכל טבלת הורה בהיררכיה:

-- Prepare a sub-partition for a non-root parent table
CALL ai.embedding_prepare_partition(
    parent_table => 'documents_eu', -- An existing partition
    child_table => 'documents_eu_germany'
);

-- Attach the new sub-partition
ALTER TABLE documents_eu ATTACH PARTITION documents_eu_germany
    FOR VALUES IN ('germany');

-- Refresh embeddings for the new sub-partition
CALL ai.refresh_embeddings(
    table_name => 'documents_eu_germany',
    embedding_column => 'content_embeddings'
);

מעקב אחרי ההתקדמות של יצירת ההטמעה

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

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

SELECT
  table_name,
  content_column,
  embedding_column,
  model_id,
  percent_progress,
  status,
  elapsed_time,
  rows_processed,
  partition_root
FROM
  ai.embedding_progress_view;

בתצוגה מופיעים הפרטים הבאים:

עמודה תיאור
table_name שם הטבלה או המחיצה שעוברת עיבוד.
content_column העמודה שמכילה את תוכן המקור להטמעה.
embedding_column העמודה שבה מאוחסנות ההטמעות.
model_id המודל שמשמש ליצירת התוכן.
percent_progress אחוז הפעולה שהושלמה.
status הסטטוס הנוכחי של הפעולה (למשל, פועלת, הצליחה).
elapsed_time הזמן שעבר מאז שהפעולה התחילה.
rows_processed מספר השורות שעובדו עד עכשיו.
partition_root השם של טבלת הבסיס שמחולקת למחיצות.

דוגמאות ליצירת הטמעות באופן אוטומטי

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

מודל ההטמעה של Google

כדי ליצור הטמעות באמצעות נקודת הקצה של המודל text-embedding-005 של Google שנרשם מראש, מריצים את ההצהרה הבאה:

CALL ai.initialize_embeddings(
    model_id => 'text-embedding-005',
    table_name => 'user_reviews',
    content_column => 'content',
    embedding_column => 'content_embeddings'
);

מודל הטמעה של OpenAI

כדי ליצור הטמעות באמצעות נקודת הקצה של המודל text-embedding-3-small שרשומה ב-OpenAI, מריצים את ההצהרה הבאה:

CALL ai.initialize_embeddings(
    model_id => 'text-embedding-3-small',
    table_name => 'user_reviews',
    content_column => 'content',
    embedding_column => 'content_embeddings'
);

מודלים של הטמעה בהתאמה אישית

כדי להשתמש במודלים בהתאמה אישית או במודלים שנתמכים באופן חיצוני, צריך להגדיר פונקציות טרנספורמציה של קלט ופלט ולרשום אותן באמצעות ai.create_model או google_ml.create_model. אם אתם מתכננים להשתמש בתכונה של הטמעה אוטומטית, אתם צריכים לציין גם פונקציות טרנספורמציה סקלריות (לדוגמה, acme_text_input_transform, acme_text_output_transform) וגם פונקציות טרנספורמציה באצווה (לדוגמה, acme_text_batch_input_transform, acme_text_batch_output_transform).

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

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