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

בוחרים גרסת תיעוד:

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

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

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

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

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

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

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

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

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

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

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

    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 מופיעה.

      מידע נוסף מופיע במאמר בנושא שליחת בקשה לשינוי המכסות.

    לגבי מגבלות של מודלים להטמעת וקטורים ב-Vertex AI, אפשר לעיין במאמר בנושא מגבלת הטוקנים של מודל Gemini להטמעת וקטורים.

    רשימה מלאה של מכסות זמינה במאמר בנושא מכסות ומגבלות ב-Vertex AI.

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

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

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

  • כדי ליצור הטמעות ממסד נתונים של AlloyDB Omni, צריך להגדיר את AlloyDB Omni כך שיפעל עם Vertex AI. מידע נוסף זמין במאמר בנושא שילוב של מסד הנתונים עם Vertex AI.

  • כדי לנהל ולעקוב אחרי יצירת הטמעה אוטומטית, המשתמשים מקבלים גישה לטבלאות 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 Omni.

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

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

הפונקציה הזו תומכת במודלים ש-Google מספקת – למשל, text-embedding-005 של Vertex AI – וגם במודלים בהתאמה אישית שרשמתם.

ביצוע יצירה של כמה פריטים

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

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

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

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

    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 של הפונקציה ומשתמש בה לעיבוד ברצף (batch processing). אם כבר יצרתם רישום של מודל שמשתמש בפונקציית טרנספורמציה JSON, אתם לא צריכים לעדכן את הקריאה ל-ai.create_model. כל עוד הפונקציה החדשה JSONB משתמשת באותו שם בדיוק כמו הפונקציה הקיימת JSON, התוסף מזהה את הווריאציה JSONB באופן שקוף ומשתמש בה לעיבוד ברצף.

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

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

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

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

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

מודל הטמעה של 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. אם אתם מתכננים להשתמש בתכונה 'הטמעה אוטומטית', אתם צריכים לציין גם פונקציות טרנספורמציה סקלריות (לדוגמה, acme_text_input_transform, ‏ acme_text_output_transform) וגם פונקציות טרנספורמציה של קבוצות (לדוגמה, acme_text_batch_input_transform, ‏ acme_text_batch_output_transform).

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