יצירת תוכן באמצעות מודלים של AI

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

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

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

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

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

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

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

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

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

המודלים שנתמכים ב-Genkit

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

צוות Genkit מנהל יישומי פלאגין לעבודה עם מודלים שסופקו על ידי Vertex AI,‏ Google Generative AI ו-Ollama:

  • משפחת ה-LLM של Gemini, דרך הפלאגין של Google Cloud Vertex AI
  • משפחת ה-LLM של Gemini, דרך הפלאגין של Google AI
  • מודלים ליצירת תמונות של Imagen2 ו-Imagen3, דרך Google Cloud Vertex AI
  • משפחת ה-LLMs של Claude 3 מ-Anthropic, דרך גן המודלים של Google Cloud Vertex AI
  • Gemma 2,‏ Llama 3 ועוד הרבה מודלים פתוחים אחרים, באמצעות הפלאגין Ollama (צריך לארח את שרת Ollama בעצמכם)

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

אפשר למצוא מידע נוסף על ידי חיפוש חבילות שמתויגות ב-genkit-model ב-npm.org.

טעינה והגדרה של יישומי פלאגין של מודלים

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

השיטה generate()‎

ב-Genkit, הממשק הראשי שבו מתבצעת האינטראקציה עם מודלים של בינה מלאכותית גנרטיבית הוא השיטה generate().

הקריאה הפשוטה ביותר ל-generate() מציינת את המודל שבו רוצים להשתמש והנחיית טקסט:

import { gemini15Flash, googleAI } from '@genkit-ai/googleai';
import { genkit } from 'genkit';

const ai = genkit({
  plugins: [googleAI()],
  model: gemini15Flash,
});

(async () => {
  const { text } = await ai.generate(
    'Invent a menu item for a pirate themed restaurant.'
  );
  console.log(text);
})();

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

## The Blackheart's Bounty

**A hearty stew of slow-cooked beef, spiced with rum and molasses, served in a
hollowed-out cannonball with a side of crusty bread and a dollop of tangy
pineapple salsa.**

**Description:** This dish is a tribute to the hearty meals enjoyed by pirates
on the high seas. The beef is tender and flavorful, infused with the warm spices
of rum and molasses. The pineapple salsa adds a touch of sweetness and acidity,
balancing the richness of the stew. The cannonball serving vessel adds a fun and
thematic touch, making this dish a perfect choice for any pirate-themed
adventure.

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

דוגמת הקוד הקודמת שלחה את בקשת היצירה למודל ברירת המחדל שציינתם כשהגדרתם את המכונה של Genkit.

אפשר גם לציין מודל לקריאה יחידה של generate():

const { text } = await ai.generate({
  model: gemini15Pro,
  prompt: 'Invent a menu item for a pirate themed restaurant.',
});

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

const { text } = await ai.generate({
  model: 'googleai/gemini-1.5-pro-latest',
  prompt: 'Invent a menu item for a pirate themed restaurant.',
});

מזהה מחרוזת של מודל נראה כך: providerid/modelid, כאשר מזהה הספק (במקרה הזה, googleai) מזהה את הפלאגין, ומזהה המודל הוא מזהה מחרוזת ספציפי לפלאגין לגרסה ספציפית של מודל.

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

הדוגמאות האלה גם מדגימות נקודה חשובה: כשמשתמשים ב-generate() כדי לבצע קריאות למודל של AI גנרטיבי, שינוי המודל שבו רוצים להשתמש הוא פשוט העברת ערך אחר לפרמטר של המודל. השימוש ב-generate() במקום ב-SDK של המודלים המקומיים מאפשר לכם להשתמש בקלות רבה יותר בכמה מודלים שונים באפליקציה ולשנות את המודלים בעתיד.

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

הנחיות מערכת

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

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

const { text } = await ai.generate({
  system: 'You are a food industry marketing consultant.',
  prompt: 'Invent a menu item for a pirate themed restaurant.',
});

פרמטרים של מודל

הפונקציה generate() מקבלת פרמטר config, שדרכו אפשר לציין הגדרות אופציונליות ששולטות באופן שבו המודל יוצר תוכן:

const { text } = await ai.generate({
  prompt: 'Invent a menu item for a pirate themed restaurant.',
  config: {
    maxOutputTokens: 400,
    stopSequences: ['<end>', '<fin>'],
    temperature: 1.2,
    topP: 0.4,
    topK: 50,
  },
});

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

פרמטרים ששולטים באורך הפלט

maxOutputTokens

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

הפרמטר maximum output tokens מגדיר פשוט את המגבלה על מספר הטוקנים שייווצרו באמצעות ה-LLM. יכול להיות שכל מודל משתמש ב-tokenizer שונה, אבל מומלץ להתייחס למילה אנגלית אחת ככזו שמכילה 2 עד 4 אסימונים.

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

stopSequences

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

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

פרמטרים ששולטים ב'קריאייטיב'

הפרמטרים temperature,‏ top-p ו-top-k קובעים יחד את מידת היצירתיות של המודל. בהמשך מופיעים הסברים קצרים מאוד על המשמעות של הפרמטרים האלה, אבל הנקודה החשובה יותר היא: הפרמטרים האלה משמשים להתאמת אופי הפלט של LLM. הערכים האופטימליים שלהם תלויים ביעדים ובהעדפות שלכם, וסביר להניח שתוכלו למצוא אותם רק באמצעות ניסוי וטעייה.

temperature

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

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

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

topP

Top-p הוא ערך בין 0.0 ל-1.0 שקובע את מספר האסימונים האפשריים שהמודל ייחשב, על ידי ציון ההסתברות המצטברת של האסימונים. לדוגמה, ערך של 1.0 מציין שצריך להביא בחשבון כל אסימון אפשרי (אבל עדיין להביא בחשבון את ההסתברות של כל אסימון). ערך של 0.4 פירושו שצריך להביא בחשבון רק את האסימונים הסבירים ביותר, שההסתברויות שלהם מצטברות ל-0.4, ולהחריג את האסימונים הנותרים מההתחשבות.

topK

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

ניסוי עם פרמטרים של מודלים

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

פלט מובנה

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

ב-Genkit, אפשר לבקש פלט מובנה מהמודל על ידי ציון סכימה בזמן הקריאה ל-generate():

import { z } from 'genkit'; // Import Zod, which is re-exported by Genkit.

const MenuItemSchema = z.object({
  name: z.string(),
  description: z.string(),
  calories: z.number(),
  allergens: z.array(z.string()),
});

const { output } = await ai.generate({
  prompt: 'Invent a menu item for a pirate themed restaurant.',
  output: { schema: MenuItemSchema },
});

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

כשמציינים סכימה ב-generate(), Genkit מבצע כמה פעולות מאחורי הקלעים:

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

כדי לקבל פלט מובנה מבקשת generate מוצלחת, משתמשים במאפיין output של אובייקט התגובה:

if (output) {
  const { name, description, calories, allergens } = output;
}

טיפול בשגיאות

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

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

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

    const MenuItemSchema = z.object({
  name: z.string(),
  description: z.string(),
  calories: z.coerce.number(),
  allergens: z.array(z.string()),
});

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

סטרימינג

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

ב-Genkit, אפשר להעביר פלט בסטרימינג באמצעות השיטה generateStream(). התחביר שלה דומה לזה של השיטה generate():

const { response, stream } = await ai.generateStream(
  'Suggest a complete menu for a pirate themed restaurant.'
);

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

for await (const chunk of stream) {
  console.log(chunk.text);
}

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

const completeText = (await response).text;

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

const MenuSchema = z.object({
  starters: z.array(MenuItemSchema),
  mains: z.array(MenuItemSchema),
  desserts: z.array(MenuItemSchema),
});

const { response, stream } = await ai.generateStream({
  prompt: 'Suggest a complete menu for a pirate themed restaurant.',
  output: { schema: MenuSchema },
});

for await (const chunk of stream) {
  // `output` is an object representing the entire output so far.
  console.log(chunk.output);
}

// Get the completed output.
const { output } = await response;

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

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

null

{ starters: [ {} ] }

{
  starters: [ { name: "Captain's Treasure Chest", description: 'A' } ]
}

{
  starters: [
    {
      name: "Captain's Treasure Chest",
      description: 'A mix of spiced nuts, olives, and marinated cheese served in a treasure chest.',
      calories: 350
    }
  ]
}

{
  starters: [
    {
      name: "Captain's Treasure Chest",
      description: 'A mix of spiced nuts, olives, and marinated cheese served in a treasure chest.',
      calories: 350,
      allergens: [Array]
    },
    { name: 'Shipwreck Salad', description: 'Fresh' }
  ]
}

קלט מרובה מצבים

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

היכולת לקבל קלט מדיה וסוג המדיה שבו אפשר להשתמש תלויים לחלוטין במודל וב-API שלו. לדוגמה, סדרת המודלים של Gemini 1.5 יכולה לקבל תמונות, סרטונים ואודיו בתור הנחיות.

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

const { text } = await ai.generate([
  { media: { url: 'https://example.com/photo.jpg' } },
  { text: 'Compose a poem about this image.' },
]);

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

import { readFile } from 'node:fs/promises';

const b64Data = await readFile('photo.jpg', { encoding: 'base64url' });
const dataUrl = `data:image/jpeg;base64,${b64Data}`;

const { text } = await ai.generate([
  { media: { url: dataUrl } },
  { text: 'Compose a poem about this image.' },
]);

כל המודלים שתומכים בהזנת מדיה תומכים גם בכתובות URL של נתונים וגם בכתובות URL מסוג HTTPS. חלק מהיישומי פלאגין של המודלים מוסיפים תמיכה במקורות מדיה אחרים. לדוגמה, הפלאגין של Vertex AI מאפשר גם להשתמש בכתובות URL של Cloud Storage‏ (gs://).

יצירת מדיה

עד כה, רוב הדוגמאות בדף הזה עסקו ביצירת טקסט באמצעות מודלים LLM. עם זאת, אפשר להשתמש ב-Genkit גם עם מודלים ליצירת תמונות. השימוש ב-generate() עם מודל ליצירת תמונות דומה לשימוש ב-LLM. לדוגמה, כדי ליצור תמונה באמצעות המודל Imagen2 דרך Vertex AI:

  1. מערכת Genkit משתמשת בכתובות URL מסוג data: כפורמט הפלט הסטנדרטי של מדיה שנוצרה. זהו פורמט סטנדרטי עם הרבה ספריות שזמינות לטיפול בהם. בדוגמה הזו נעשה שימוש בחבילה data-urls מ-jsdom:

    npm i --save data-urls
npm i --save-dev @types/data-urls

  2. כדי ליצור תמונה ולשמור אותה בקובץ, קוראים לפונקציה generate() ומציינים מודל ליצירת תמונות וסוג המדיה של פורמט הפלט:

    import { imagen3Fast, vertexAI } from '@genkit-ai/vertexai';
import parseDataURL from 'data-urls';
import { genkit } from 'genkit';

import { writeFile } from 'node:fs/promises';

const ai = genkit({
  plugins: [vertexAI({ location: 'us-central1' })],
});

(async () => {
  const { media } = await ai.generate({
    model: imagen3Fast,
    prompt: 'photo of a meal fit for a pirate',
    output: { format: 'media' },
  });

  if (media === null) throw new Error('No media generated.');

  const data = parseDataURL(media.url);
  if (data === null) throw new Error('Invalid "data:" URL.');

  await writeFile(`output.${data.mimeType.subtype}`, data.body);
})();

השלבים הבאים

מידע נוסף על Genkit

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

שימוש מתקדם ב-LLM

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

בדיקת הפלט של המודל

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

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