Jev: מודל ה-AI שאף פעם לא כותב מילה

רוב מודלי ה-AI היום בנויים כדי לדבר. שואלים שאלה, והם כותבים תשובה.

Jev, המודל הראשון של הסטארט-אפ TypeSafe AI מסן פרנסיסקו, לא כותב אף מילה. נותנים לו טקסט ורשימת שאלות, והוא מחזיר תשובות מוקלדות (Typed): תווית, ציון או הסתברות, שהקוד שלכם יכול להשתמש בהן מיד.

TypeSafe השיקה את Jev בגישה מוקדמת ב-15 בספטמבר, יחד עם סבב סיד של 40 מיליון דולר בהובלת DCVC. אחד המייסדים הוא דיוגו אלמיידה, שעבד כארבע שנים ב-OpenAI על RLHF, על InstructGPT ועל ChatGPT. כך הסביר ל-TechCrunch למה התחיל את הפרויקט: "יש לנו ברק בבקבוק, ובכל זאת הוא לא שימושי."

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

הבעיה ש-Jev מנסה לפתור

חלק גדול מה-AI בתוכנות אמיתיות הוא לא שיחה. הוא החלטה קטנה בתוך תוכנה:

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

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

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

מה מייחד את Jev

לבקשה ל-Jev יש שני חלקים:

1. מצב (State) – טקסט הקלט. הוא יכול להיות מחרוזת, אובייקט JSON או מערך של טקסטים.
2. שאלות (Questions) – שאלה מוקלדת אחת או יותר על המצב.

יש רק שלושה סוגי שאלות, ש-TypeSafe קוראת להם פרימיטיבים:

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

TypeSafe מכנה את Jev מודל "System One", על שם הרעיון של דניאל כהנמן על חשיבה מהירה ואינטואיטיבית. מודל שפה שחושב צעד אחרי צעד קרוב יותר ל-System Two: איטי וזהיר.

אומן להסתברויות כנות, לא כדי לרצות אנשים

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

Jev משתמש בשיטה ש-TypeSafe קוראת לה RLCD (Reinforcement Learning for Calibrated Decisions). המטרה היא כיול: על פני הרבה תשובות, דברים ש-Jev מעריך ב-80% צריכים להתברר כנכונים בערך ב-80% מהמקרים. כך ההסתברות הופכת למשהו שהקוד יכול לסמוך עליו ולפעול לפיו.

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

למה Jev כל כך זול?

המחיר הוא 0.042 דולר למיליון טוקני קלט, וטוקני הפלט בחינם. לשם השוואה, קריאת מסמך של 10,000 טוקנים עולה בערך 0.0004 דולר.

שלוש החלטות תכנון מסבירות את רוב החיסכון:

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

2. קוראים פעם אחת, שואלים הרבה. Jev קורא את המצב פעם אחת ובודק מולו את כל השאלות במקביל. בבדיקה של TypeSafe עצמה, עם 13 שאלות על מאמר ארוך, קריאה אחת מאוחדת הייתה זולה פי 12.2 ומהירה פי 10 מ-13 קריאות נפרדות, עם אותן תשובות.

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

TypeSafe מדווחת על זמני תגובה של 70 עד 500 מילישניות, וטוענת ש-Jev מהיר פי 40 עד 200 וזול פי 40 עד 400 ממודלי חזית במשימות דומות. כדאי להתייחס למספרים האלה כשיווקיים. TypeSafe עצמה מציינת שהצוות שלה בנה את תהליכי הבדיקה, שייתכנת הטיה, ושהתוצאות כנראה נמצאות בקצה הגבוה. תמיד כדאי למדוד על הנתונים שלכם.

איך משתמשים ב-Jev

אפשר לנסות אותו ב-Playground בלי לכתוב קוד. לשימוש אמיתי, מתקינים את ה-SDK של Python ‏(pip install typesafe-sdk). הדוגמה הבאה, שמבוססת על מדריך ההתחלה, מנתבת פניית תמיכה:

from typesafe_sdk import Choice, Noul, Score, TypeSafeClient

client = TypeSafeClient()  # reads TYPESAFE_API_KEY

ticket = "My Stripe integration has failed for 3 days. I'm losing sales. Please help ASAP."

result = client.system_one(
    state=ticket,
    questions={
        "department": Choice(
            instructions="Which team should handle this",
            criteria={
                "billing": "Payment or subscription issues",
                "technical": "Bugs or integration problems",
                "sales": "Pricing or account questions",
            },
        ),
        "frustration": Score(
            instructions="How frustrated the customer appears",
            criteria=["Calm", "Frustrated but civil", "Very angry"],
        ),
        "is_urgent": Noul(instructions="The message conveys urgency"),
    },
)

dept = result.answers["department"]
print(dept.choice, dept.confidence)  # e.g. "technical" 0.78

כל תשובה מסוג Choice או Score כוללת ערך ביטחון (Confidence) בין 0 ל-1. זה החלק השימושי ביותר בתכנון: התשובה אומרת לכם מה, והביטחון אומר לכם אם לפעול.

if dept.confidence >= 0.9:
    assign_ticket(dept.choice)
elif dept.confidence >= 0.6:
    assign_ticket(dept.choice, needs_review=True)
else:
    send_to_human(ticket)

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

איפה Jev עוזר, ואיפה לא

שימושים מתאימים:

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

דפוס נפוץ הוא מפל (Cascade): Jev מטפל במקרים הקלים והנפוצים, ורק המקרים הלא ודאיים עוברים למודל שפה גדול או לאדם.

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

• הוא קורא באופן מילולי. הוא עונה על השאלה שכתבתם, לא על זו שהתכוונתם אליה.
• הוא חלש במתמטיקה, בספירה ובהשוואת תאריכים. את אלה עושים בקוד.
• ההסתברויות לא תמיד מסתכמות. Noul והשאלה ההפוכה לו יכולים להסתכם ביותר מ-1.
• טקסט בלבד, ובעיקר אנגלית. שפות אחרות עובדות, אבל פחות טוב. המגבלה היא 64 אלף טוקנים לבקשה.

זווית האבטחה: "לא יכול להזות" זה לא "לא יכול להיות מוטעה"

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

TypeSafe מציינת ש-Jev לא מתייחס כברירת מחדל למצב כאל תוכן עוין. טקסט שנכתב כדי להטות את המודל, למשל הוראה מוזרקת, יכול להזיז את התשובה. לכן אם משתמשים ב-Jev כמעקה בטיחות לתוכן של משתמשים או מהאינטרנט, תוקף עשוי לנסות לכתוב תוכן שמשכנע את המודל לתת לו תווית "בטוח".

כללים מעשיים:

• התייחסו לפלט של Jev כאל אות, לא כאל הרשאה. השאירו בקרות גישה אמיתיות בקוד.
• השתמשו בספים גבוהים יותר לפעולות מסוכנות, והעבירו מקרים עם ביטחון נמוך לאדם.
• בדקו עם דוגמאות עוינות לפני שמשחררים.
• קבעו גרסת מודל, למשל jev-1.13.0. הכינוי jev-latest יכול להשתנות, והספים שכיווננתם עלולים לזוז יחד איתו.

השורה התחתונה

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

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

מקורות

• ויקיפדיה: Jev (AI model)
• תיעוד TypeSafe: ‏System One
• תיעוד TypeSafe: מדריך התחלה
• תיעוד TypeSafe: מודלים ותמחור
• תיעוד TypeSafe: מבוא ל-AI ול-RLCD
• תיעוד TypeSafe: ביטחון
• תיעוד TypeSafe: שאלות מקביליות
• תיעוד TypeSafe: מגבלות ידועות של Jev 1.13
• TechCrunch: סוג חדש של מודל AI מאחד הממציאים של ChatGPT

התרשימים נוצרו עבור מאמר זה. תמונת הנושא: מסגרת הידיות בתא האיתות בניו רומני, צילום מאת John K Thorne, נחלת הכלל.