Open Source LLM

מודלי שפה מודרניים כמו Llama 3 ו-Qwen 2.5 נראים ממבט ראשון כמו ה-Transformer המקורי מ-2017, אך מתחת למכסה המנוע הם עברו אבולוציה ארכיטקטונית דרמטית. במקום הארכיטקטורה הסטנדרטית של GPT-2, מודלים מודרניים אלו מתבססים על שילוב של ארבעה רכיבי מפתח: RMSNorm לייצוב הצימוד, SwiGLU כפונקציית אקטיבציה מתקדמת ב-FFN, RoPE לייצוג מיקום סיבובי, ו-GQA (Grouped-Query Attention) המאפשר יעילות חישובית יוצאת דופן בזמן הסקה (Inference). הבנת הרכיבים הללו היא קריטית לכל מי שמפתח, מאמן או מבצע אופטימיזציה למודלי קצה.

נתחיל בשיפורי היציבות והחישוב: RMSNorm (Root Mean Square Normalization) מחליף את ה-LayerNorm המסורתי על ידי ויתור על חישוב הממוצע (mean centering), מה שמקצר את זמן החישוב ב-10%-50% מבלי לפגוע בביצועים. בגזרת האקטיבציה, SwiGLU מחליפה את ה-GELU הסטנדרטית; היא משלבת את פונקציית Swish עם מנגנון Gated Linear Unit, מה שמאפשר למודל ללמוד ייצוגים מורכבים יותר אך דורש הגדלה קלה של מספר הפרמטרים בשכבת ה-Feed-Forward.

השינוי המשמעותי ביותר בביצועי ההקשר (Context Window) מגיע מ-RoPE (Rotary Position Embedding) ו-GQA. RoPE מייצג מיקום יחסי על ידי סיבוב וקטורי ה-Query וה-Key במרחב הדו-ממדי, מה שמאפשר אקסטרפולציה חלקה לאורכי הקשר עצומים (כמו 128K ב-Llama 3). במקביל, GQA פותר את צוואר הבקבוק של ה-KV Cache על ידי חלוקת ה-Keys וה-Values לקבוצות (Groups), כך שמספר ראשי ה-Query גדול ממספר ראשי ה-KV. זה מקטין דרמטית את דרישות הזיכרון בזמן Inference ומאפשר Batch Size גדול בהרבה.

כדי להבין איך הרכיבים הללו מתחברים יחד, מומלץ להסתכל על מימוש נקי של השכבות הללו. ספריית x-transformers של lucidrains מאפשרת להגדיר מודלים מותאמים אישית עם הרכיבים הללו בשורות קוד בודדות. הנה דוגמה קצרה להגדרת Transformer מודרני המשתמש ב-RMSNorm, SwiGLU ו-RoPE:

from x_transformers import TransformerWrapper, Decoder

# הגדרת מודל דמוי Llama עם ארכיטקטורה מודרנית
model = TransformerWrapper(
    num_tokens = 20000,
    max_seq_len = 1024,
    attn_layers = Decoder(
        dim = 512,
        depth = 6,
        heads = 8,
        attn_flash = True,           # שימוש ב-Flash Attention ליעילות
        rotary_pos_emb = True,       # RoPE (Rotary Position Embedding)
        ff_glu = True,               # SwiGLU Activation
        rms_norm = True              # RMSNorm במקום LayerNorm
    )
)

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

הצעד הבא שלכם: הורידו ושבטו את ה-Repository הרשמי של Llama 3 Implementation. עברו על קובץ model.py והתמקדו במימוש של פונקציית precompute_freqs_cis (המשמשת עבור RoPE) ובמחלקה Attention המממשת את ה-GQA. הריצו את ה-minimal generation script שלהם כדי לראות את הקוד פועל מקצה לקצה.

משפחת מודלי Llama מבית Meta חוללה מהפכה בעולם ה-AI בקוד פתוח, כאשר סדרת Llama 3.x מייצגת את חזית הטכנולוגיה הנוכחית עבור מפתחים וחוקרים. מודלים אלו אומנו על כמויות עצומות של נתונים (טריליוני tokens) ומציעים ביצועים המתחרים במודלים מסחריים סגורים. הסדרה כוללת מודלים בגדלים שונים (כמו 8B, 70B ו-405B) המותאמים לצרכים שונים – החל מהרצה מקומית על מחשב נייד ועד לפריסות ענן מסיביות, כאשר גרסאות ה-Instruction-tuned עברו כוונון עדין מיוחד כדי להבין ולבצע הוראות מורכבות של משתמשים בצורה טבעית ומדויקת.

השימוש ב-Llama 3.x מומלץ במיוחד כאשר יש צורך בפרטיות מידע מלאה, שליטה בעלויות ה-Inference, או התאמה אישית (Fine-tuning) של המודל למשימות ספציפיות. בניגוד לשימוש ב-APIs סגורים של חברות כמו OpenAI או Anthropic, הרצת Llama 3.x מקומית או על שרת פרטי מבטיחה שהנתונים הרגישים שלכם לעולם לא יעזבו את הארגון. בנוסף, הגרסאות הקטנות יותר (כמו Llama 3 8B) מציעות יחס עלות-תועלת מעולה, ומאפשרות לבנות יישומי סוכנים (Agents) ומערכות RAG (Retrieval-Augmented Generation) יעילות ומהירות במיוחד.

כדי להתחיל לעבוד עם Llama 3.x, הדרך הפשוטה והמהירה ביותר היא שימוש בכלים כמו Ollama, המאפשר להריץ את המודל מקומית בפקודה אחת פשוטה, או בפרויקט llama.cpp המאפשר ביצועים אופטימליים על מעבדים רגילים (CPU) וכרטיסי מסך מגוונים באמצעות קוונטיזציה (Quantization) בפורמט GGUF. לאחר שהמודל רץ מקומית, ניתן לחבר אותו בקלות לספריות פיתוח פופולריות כמו LlamaIndex כדי להתחיל לתשאל מסמכים ולבנות יישומי בינה מלאכותית מתקדמים.

הנה דוגמה קצרה המציגה כיצד לפנות למודל Llama 3 הרץ באופן מקומי באמצעות Ollama ולתשאל אותו בעזרת קוד Python פשוט:

import requests

url = "http://localhost:11434/api/generate"
payload = {
    "model": "llama3",
    "prompt": "Explain briefly what a Large Language Model is.",
    "stream": False
}

response = requests.post(url, json=payload)
print(response.json().get("response"))

ככל שהפרויקט שלכם גדל, תרצו לשלב את Llama 3.x עם מנועי חיפוש ומאגרי מידע. ספריות כמו LlamaIndex מעדכנות באופן תדיר את התמיכה שלהן במודלים אלו ובאינטגרציות השונות. מומלץ לעקוב אחר העדכונים האחרונים, כגון LlamaIndex v0.14.19 וכן LlamaIndex v0.14.18, המציגים שיפורים בליבת המערכת וביכולות העבודה עם סוכני AI ומודלים מקומיים, כפי שמתואר גם בגרסת llama-index-core 0.14.16.

הצעד הבא שלכם: הורידו והתקינו את Ollama במחשב שלכם. לאחר ההתקנה, פתחו את הטרמינל והריצו את הפקודה ollama run llama3 כדי להתחיל לשוחח עם המודל ישירות מה-CLI. לאחר מכן, נסו להריץ את קוד הפייתון שלמעלה כדי לחבר את המודל לאפליקציה הראשונה שלכם!

משפחת מודלי Llama מבית Meta חוללה מהפכה בעולם ה-AI בקוד פתוח, כאשר סדרת Llama 3.x מייצגת את חזית הטכנולוגיה הנוכחית עבור מפתחים וחוקרים. מודלים אלו אומנו על כמויות עצומות של נתונים (טריליוני tokens) ומציעים ביצועים המתחרים במודלים מסחריים סגורים. הסדרה כוללת מודלים בגדלים שונים (כמו 8B, 70B ו-405B) המותאמים לצרכים שונים – החל מהרצה מקומית על מחשב נייד ועד לפריסות ענן מסיביות, כאשר גרסאות ה-Instruction-tuned עברו כוונון עדין מיוחד כדי להבין ולבצע הוראות מורכבות של משתמשים בצורה טבעית ומדויקת.

השימוש ב-Llama 3.x מומלץ במיוחד כאשר יש צורך בפרטיות מידע מלאה, שליטה בעלויות ה-Inference, או התאמה אישית (Fine-tuning) של המודל למשימות ספציפיות. בניגוד לשימוש ב-APIs סגורים של חברות כמו OpenAI או Anthropic, הרצת Llama 3.x מקומית או על שרת פרטי מבטיחה שהנתונים הרגישים שלכם לעולם לא יעזבו את הארגון. בנוסף, הגרסאות הקטנות יותר (כמו Llama 3 8B) מציעות יחס עלות-תועלת מעולה, ומאפשרות לבנות יישומי סוכנים (Agents) ומערכות RAG (Retrieval-Augmented Generation) יעילות ומהירות במיוחד.

כדי להתחיל לעבוד עם Llama 3.x, הדרך הפשוטה והמהירה ביותר היא שימוש בכלים כמו Ollama, המאפשר להריץ את המודל מקומית בפקודה אחת פשוטה, או בפרויקט llama.cpp המאפשר ביצועים אופטימליים על מעבדים רגילים (CPU) וכרטיסי מסך מגוונים באמצעות קוונטיזציה (Quantization) בפורמט GGUF. לאחר שהמודל רץ מקומית, ניתן לחבר אותו בקלות לספריות פיתוח פופולריות כמו LlamaIndex כדי להתחיל לתשאל מסמכים ולבנות יישומי בינה מלאכותית מתקדמים.

הנה דוגמה קצרה המציגה כיצד לפנות למודל Llama 3 הרץ באופן מקומי באמצעות Ollama ולתשאל אותו בעזרת קוד Python פשוט:

import requests

url = "http://localhost:11434/api/generate"
payload = {
    "model": "llama3",
    "prompt": "Explain briefly what a Large Language Model is.",
    "stream": False
}

response = requests.post(url, json=payload)
print(response.json().get("response"))

ככל שהפרויקט שלכם גדל, תרצו לשלב את Llama 3.x עם מנועי חיפוש ומאגרי מידע. ספריות כמו LlamaIndex מעדכנות באופן תדיר את התמיכה שלהן במודלים אלו ובאינטגרציות השונות. מומלץ לעקוב אחר העדכונים האחרונים, כגון LlamaIndex v0.14.19 וכן LlamaIndex v0.14.18, המציגים שיפורים בליבת המערכת וביכולות העבודה עם סוכני AI ומודלים מקומיים, כפי שמתואר גם בגרסת llama-index-core 0.14.16.

הצעד הבא שלכם: הורידו והתקינו את Ollama במחשב שלכם. לאחר ההתקנה, פתחו את הטרמינל והריצו את הפקודה ollama run llama3 כדי להתחיל לשוחח עם המודל ישירות מה-CLI. לאחר מכן, נסו להריץ את קוד הפייתון שלמעלה כדי לחבר את המודל לאפליקציה הראשונה שלכם!

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

הכוח של מודלים אלו טמון ביעילות הארכיטקטונית שלהם. מודלי DeepSeek, למשל, עושים שימוש נרחב בטכנולוגיית Mixture of Experts (MoE) המאפשרת להפעיל רק חלק קטן מהפרמטרים בכל שאילתה, ובכך לחסוך משאבי חישוב עצומים מבלי לפגוע באיכות התשובה. מנגד, סדרת Qwen2.5 מציעה ביצועים פנומנליים במגוון שפות ויכולות קידוד שמאתגרות את המודלים הסגורים המובילים בשוק. השימוש במודלים אלו מומלץ במיוחד כאשר נדרשת פריסה מקומית (On-premise) של מודלים חזקים, או כאשר יש צורך בביצועים גבוהים בעלויות תפעול נמוכות.

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

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

להלן דוגמה מינימלית להרצת שאילתה מקומית מול מודל DeepSeek באמצעות ספריית Python הרשמית של Ollama:

import ollama

# שליחת שאילתה למודל DeepSeek-R1 המורץ מקומית
response = ollama.chat(model='deepseek-r1:8b', messages=[
    {
        'role': 'user',
        'content': 'Explain the difference between MoE and dense LLMs in one sentence.',
    },
])

print(response['message']['content'])

הצעד הבא שלכם:

הורידו והתקינו את Ollama על המחשב שלכם. לאחר מכן, פתחו את הטרמינל והריצו את הפקודה ollama run deepseek-r1:8b (או qwen2.5:14b). הפרויקט הראשון שלכם יהיה לבנות סקריפט Python קצר המשתמש במודל המקומי כדי לנתח קובץ קוד מקור ולמצוא בו באגים - ללא צורך בחיבור לאינטרנט או בתשלום על API!

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

הכוח של מודלים אלו טמון ביעילות הארכיטקטונית שלהם. מודלי DeepSeek, למשל, עושים שימוש נרחב בטכנולוגיית Mixture of Experts (MoE) המאפשרת להפעיל רק חלק קטן מהפרמטרים בכל שאילתה, ובכך לחסוך משאבי חישוב עצומים מבלי לפגוע באיכות התשובה. מנגד, סדרת Qwen2.5 מציעה ביצועים פנומנליים במגוון שפות ויכולות קידוד שמאתגרות את המודלים הסגורים המובילים בשוק. השימוש במודלים אלו מומלץ במיוחד כאשר נדרשת פריסה מקומית (On-premise) של מודלים חזקים, או כאשר יש צורך בביצועים גבוהים בעלויות תפעול נמוכות.

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

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

להלן דוגמה מינימלית להרצת שאילתה מקומית מול מודל DeepSeek באמצעות ספריית Python הרשמית של Ollama:

import ollama

# שליחת שאילתה למודל DeepSeek-R1 המורץ מקומית
response = ollama.chat(model='deepseek-r1:8b', messages=[
    {
        'role': 'user',
        'content': 'Explain the difference between MoE and dense LLMs in one sentence.',
    },
])

print(response['message']['content'])

הצעד הבא שלכם:

הורידו והתקינו את Ollama על המחשב שלכם. לאחר מכן, פתחו את הטרמינל והריצו את הפקודה ollama run deepseek-r1:8b (או qwen2.5:14b). הפרויקט הראשון שלכם יהיה לבנות סקריפט Python קצר המשתמש במודל המקומי כדי לנתח קובץ קוד מקור ולמצוא בו באגים - ללא צורך בחיבור לאינטרנט או בתשלום על API!

כאשר אנו נדרשים להתאים מודל שפה גדול (LLM) למשימות ספציפיות, לעיצוב סגנון כתיבה ייחודי או להבנת דומיין מקצועי צר, שימוש ב-Prompt Engineering או RAG לא תמיד מספיק. כאן נכנס לתמונה תהליך ה-Fine-tuning (כוונון עדין). ברמת המתקדמים, אנו מבחינים בין שלוש גישות מרכזיות: Full Supervised Fine-Tuning (Full SFT), LoRA (Low-Rank Adaptation), ו-QLoRA (Quantized LoRA). הבנת ההבדלים ביניהן קריטית לניהול יעיל של משאבי מחשוב (Compute) וזמן ריצה.

שיטת Full SFT מעדכנת את כל המשקולות של המודל. היא מניבה את התוצאות המדויקות ביותר עבור שינויים התנהגותיים עמוקים, אך דורשת משאבי חומרה עצומים (מערכים מרובי GPUs). לעומתה, LoRA מקפיאה את משקולות המקור ומחדירה מטריצות קטנות ורזות (Low-Rank) לשכבות הצימוד (Attention), מה שמפחית את הזיכרון הנדרש באופן דרמטי. QLoRA לוקחת את זה צעד קדימה ומבצעת קוונטיזציה של מודל הבסיס ל-4-bit, מה שמאפשר להריץ Fine-tuning של מודלים ענקיים על גבי GPU צרכני בודד מבלי לפגוע כמעט בביצועים.

כדי ליישם את השיטות הללו בפועל, קהילת ה-Open Source מציעה שני כלים מובילים. הראשון הוא unsloth, ספרייה המאפשרת האצה של פי 2 במהירות וחיסכון של עד 80% בזיכרון ה-VRAM עבור מודלים פופולריים כמו Llama 3 ו-Mistral. הכלי השני הוא axolotl, פלטפורמה מבוססת קובצי קונפיגורציה (YAML) המיועדת לאימונים מבוזרים ומורכבים על גבי מספר כרטיסי מסך (Multi-GPU).

להלן דוגמה קצרה ופשוטה לשימוש ב-Unsloth לצורך טעינת מודל והכנתו ל-LoRA מהיר:

from unsloth import FastLanguageModel
import torch

max_seq_length = 2048
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/llama-3-8b-Instruct-bnb-4bit",
    max_seq_length = max_seq_length,
    load_in_4bit = True,
)

model = FastLanguageModel.get_peft_model(
    model,
    r = 16,
    target_modules = ["q_proj", "k_proj", "v_proj", "o_proj"],
    lora_alpha = 16,
    lora_dropout = 0,
    bias = "none",
)

לאחר שהמודל עבר התאמה אישית, הוא הופך ללב הפועם של מערכות מורכבות יותר. שילוב מודלים מותאמים אישית בתוך סוכני AI (Agents) מאפשר להשיג רמת ביצועים חסרת תקדים. כדי להבין כיצד לנהל את מחזור החיים של סוכנים אלו ולשמור על עקביות, מומלץ לקרוא על פיתוחים אחרונים בניהול State בגרסת LangGraph 1.2.1 או להעמיק בניהול זיכרון מתקדם עם langgraph-checkpoint 4.1.1. בנוסף, לדיון מרתק על האופן שבו מודלים מותאמים אישית מעצבים מחדש את תהליכי היצירה האנושיים, מומלץ לעיין במאמר הגברת יצירתיות בעידן ה-AI של MIT Tech Review.

הצעד הבא שלך: התחל בהרצת מחברת ה-Colab הרשמית של unsloth. בחר במודל Llama 3 8B, טען סט נתונים קטן משלך בפורמט Instruction (למשל, קובץ JSON פשוט המכיל שאלות ותשובות), והרץ אימון QLoRA מהיר בחינם. זה ייתן לך הבנה מעשית ראשונה של מהירות האימון וצריכת הזיכרון בפועל.

כאשר אנו נדרשים להתאים מודל שפה גדול (LLM) למשימות ספציפיות, לעיצוב סגנון כתיבה ייחודי או להבנת דומיין מקצועי צר, שימוש ב-Prompt Engineering או RAG לא תמיד מספיק. כאן נכנס לתמונה תהליך ה-Fine-tuning (כוונון עדין). ברמת המתקדמים, אנו מבחינים בין שלוש גישות מרכזיות: Full Supervised Fine-Tuning (Full SFT), LoRA (Low-Rank Adaptation), ו-QLoRA (Quantized LoRA). הבנת ההבדלים ביניהן קריטית לניהול יעיל של משאבי מחשוב (Compute) וזמן ריצה.

שיטת Full SFT מעדכנת את כל המשקולות של המודל. היא מניבה את התוצאות המדויקות ביותר עבור שינויים התנהגותיים עמוקים, אך דורשת משאבי חומרה עצומים (מערכים מרובי GPUs). לעומתה, LoRA מקפיאה את משקולות המקור ומחדירה מטריצות קטנות ורזות (Low-Rank) לשכבות הצימוד (Attention), מה שמפחית את הזיכרון הנדרש באופן דרמטי. QLoRA לוקחת את זה צעד קדימה ומבצעת קוונטיזציה של מודל הבסיס ל-4-bit, מה שמאפשר להריץ Fine-tuning של מודלים ענקיים על גבי GPU צרכני בודד מבלי לפגוע כמעט בביצועים.

כדי ליישם את השיטות הללו בפועל, קהילת ה-Open Source מציעה שני כלים מובילים. הראשון הוא unsloth, ספרייה המאפשרת האצה של פי 2 במהירות וחיסכון של עד 80% בזיכרון ה-VRAM עבור מודלים פופולריים כמו Llama 3 ו-Mistral. הכלי השני הוא axolotl, פלטפורמה מבוססת קובצי קונפיגורציה (YAML) המיועדת לאימונים מבוזרים ומורכבים על גבי מספר כרטיסי מסך (Multi-GPU).

להלן דוגמה קצרה ופשוטה לשימוש ב-Unsloth לצורך טעינת מודל והכנתו ל-LoRA מהיר:

from unsloth import FastLanguageModel
import torch

max_seq_length = 2048
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/llama-3-8b-Instruct-bnb-4bit",
    max_seq_length = max_seq_length,
    load_in_4bit = True,
)

model = FastLanguageModel.get_peft_model(
    model,
    r = 16,
    target_modules = ["q_proj", "k_proj", "v_proj", "o_proj"],
    lora_alpha = 16,
    lora_dropout = 0,
    bias = "none",
)

לאחר שהמודל עבר התאמה אישית, הוא הופך ללב הפועם של מערכות מורכבות יותר. שילוב מודלים מותאמים אישית בתוך סוכני AI (Agents) מאפשר להשיג רמת ביצועים חסרת תקדים. כדי להבין כיצד לנהל את מחזור החיים של סוכנים אלו ולשמור על עקביות, מומלץ לקרוא על פיתוחים אחרונים בניהול State בגרסת LangGraph 1.2.1 או להעמיק בניהול זיכרון מתקדם עם langgraph-checkpoint 4.1.1. בנוסף, לדיון מרתק על האופן שבו מודלים מותאמים אישית מעצבים מחדש את תהליכי היצירה האנושיים, מומלץ לעיין במאמר הגברת יצירתיות בעידן ה-AI של MIT Tech Review.

הצעד הבא שלך: התחל בהרצת מחברת ה-Colab הרשמית של unsloth. בחר במודל Llama 3 8B, טען סט נתונים קטן משלך בפורמט Instruction (למשל, קובץ JSON פשוט המכיל שאלות ותשובות), והרץ אימון QLoRA מהיר בחינם. זה ייתן לך הבנה מעשית ראשונה של מהירות האימון וצריכת הזיכרון בפועל.

כשמדובר בפריסה של מודלי שפה גדולים (LLMs) בסביבת ייצור (Production), הרצה פשוטה באמצעות ספריות כמו transformers של Hugging Face כבר אינה מספיקה. כאן נכנסים לתמונה מנועי Inference מתקדמים כמו vLLM ו-TGI (Text Generation Inference). מנועים אלו תוכננו במיוחד כדי למקסם את ה-throughput (קצב הפקת הטוקנים) ולמזער את ה-latency (זמן התגובה) על ידי אופטימיזציות ברמת החומרה והזיכרון.

מדוע אנו זקוקים להם? האתגר הגדול ביותר בהרצת LLMs הוא ניהול זיכרון ה-KV Cache (מפתח-ערך) של המודל. טכנולוגיית PagedAttention, שהוצגה לראשונה ב-vLLM, פותרת את בעיית הפרגמנטציה של הזיכרון על ידי חלוקתו לדפים דינמיים, בדומה לניהול זיכרון וירטואלי במערכות הפעלה. בנוסף, מנגנון ה-Continuous Batching (או In-flight Batching) מאפשר להכניס בקשות חדשות ל-batch הקיים בזמן אמת מבלי להמתין שכל הבקשות הקודמות יסתיימו, מה שמעלה את הניצולת של ה-GPU במאות אחוזים.

כדי להריץ מודלים ענקיים על חומרה מוגבלת, מנועים אלו תומכים בטכניקות דחיסה וקוונטיזציה (Quantization) מתקדמות כמו AWQ, GPTQ ו-FP8. שימוש בפורמטים אלו מאפשר להקטין את נפח המודל בזיכרון ה-VRAM כמעט ללא פגיעה בדיוק הכללי של המודל. בחירה בפתרון כמו vLLM מאפשרת גם חשיפה קלה של השרת כ-API התואם לחלוטין ל-OpenAI, מה שמקל על אינטגרציה מהירה עם ספריות קיימות.

הנה דוגמה קצרה ופשוטה להרצת מודל מקומי באמצעות vLLM וכתיבת קוד Python מהיר להפקת טקסט:

from vllm import LLM, SamplingParams

# טעינת המודל עם תמיכה ב-PagedAttention באופן אוטומטי
llm = LLM(model="facebook/opt-125m")

# הגדרת פרמטרים להפקה
sampling_params = SamplingParams(temperature=0.8, top_p=0.95, max_tokens=50)

# הרצת ה-Inference על מספר פרומפטים במקביל (Batching)
prompts = ["Hello, my name is", "The capital of France is"]
outputs = llm.generate(prompts, sampling_params)

for output in outputs:
    print(f"Prompt: {output.prompt!r} -> Generated: {output.outputs[0].text!r}")

המעבר לעבודה עם מנועי הסקה יעילים כמו vLLM ו-TGI הוא קריטי במיוחד כאשר דנים במגמות של מודלים פתוחים מול סגורים, כפי שמתואר בפודקאסט האגדה על מלחמות המודלים: פתוח vs סגור ב-2026. בנוסף, חברות רבות מעבירות את עומסי העבודה שלהן לעננים ייעודיים (Neoclouds) כדי לחסוך בעלויות ה-GPU, נושא שעולה לדיון בפרק המיית של Mythos ו-Allbirds טוען לטיסה ל-neocloud.

הצעד הבא שלך: התקן את vLLM על שרת עם GPU (או ב-Google Colab עם כרטיס T4/A100). הרץ את השרת כ-API תואם OpenAI באמצעות הפקודה הבאה:

python -m vllm.entrypoints.openai.api_server --model facebook/opt-125m

לאחר מכן, שלח בקשת POST פשוטה באמצעות curl או ספריית openai הרשמית ובדוק את מהירות התגובה (Tokens per second) בהשוואה להרצה רגילה.

כשמדובר בפריסה של מודלי שפה גדולים (LLMs) בסביבת ייצור (Production), הרצה פשוטה באמצעות ספריות כמו transformers של Hugging Face כבר אינה מספיקה. כאן נכנסים לתמונה מנועי Inference מתקדמים כמו vLLM ו-TGI (Text Generation Inference). מנועים אלו תוכננו במיוחד כדי למקסם את ה-throughput (קצב הפקת הטוקנים) ולמזער את ה-latency (זמן התגובה) על ידי אופטימיזציות ברמת החומרה והזיכרון.

מדוע אנו זקוקים להם? האתגר הגדול ביותר בהרצת LLMs הוא ניהול זיכרון ה-KV Cache (מפתח-ערך) של המודל. טכנולוגיית PagedAttention, שהוצגה לראשונה ב-vLLM, פותרת את בעיית הפרגמנטציה של הזיכרון על ידי חלוקתו לדפים דינמיים, בדומה לניהול זיכרון וירטואלי במערכות הפעלה. בנוסף, מנגנון ה-Continuous Batching (או In-flight Batching) מאפשר להכניס בקשות חדשות ל-batch הקיים בזמן אמת מבלי להמתין שכל הבקשות הקודמות יסתיימו, מה שמעלה את הניצולת של ה-GPU במאות אחוזים.

כדי להריץ מודלים ענקיים על חומרה מוגבלת, מנועים אלו תומכים בטכניקות דחיסה וקוונטיזציה (Quantization) מתקדמות כמו AWQ, GPTQ ו-FP8. שימוש בפורמטים אלו מאפשר להקטין את נפח המודל בזיכרון ה-VRAM כמעט ללא פגיעה בדיוק הכללי של המודל. בחירה בפתרון כמו vLLM מאפשרת גם חשיפה קלה של השרת כ-API התואם לחלוטין ל-OpenAI, מה שמקל על אינטגרציה מהירה עם ספריות קיימות.

הנה דוגמה קצרה ופשוטה להרצת מודל מקומי באמצעות vLLM וכתיבת קוד Python מהיר להפקת טקסט:

from vllm import LLM, SamplingParams

# טעינת המודל עם תמיכה ב-PagedAttention באופן אוטומטי
llm = LLM(model="facebook/opt-125m")

# הגדרת פרמטרים להפקה
sampling_params = SamplingParams(temperature=0.8, top_p=0.95, max_tokens=50)

# הרצת ה-Inference על מספר פרומפטים במקביל (Batching)
prompts = ["Hello, my name is", "The capital of France is"]
outputs = llm.generate(prompts, sampling_params)

for output in outputs:
    print(f"Prompt: {output.prompt!r} -> Generated: {output.outputs[0].text!r}")

המעבר לעבודה עם מנועי הסקה יעילים כמו vLLM ו-TGI הוא קריטי במיוחד כאשר דנים במגמות של מודלים פתוחים מול סגורים, כפי שמתואר בפודקאסט האגדה על מלחמות המודלים: פתוח vs סגור ב-2026. בנוסף, חברות רבות מעבירות את עומסי העבודה שלהן לעננים ייעודיים (Neoclouds) כדי לחסוך בעלויות ה-GPU, נושא שעולה לדיון בפרק המיית של Mythos ו-Allbirds טוען לטיסה ל-neocloud.

הצעד הבא שלך: התקן את vLLM על שרת עם GPU (או ב-Google Colab עם כרטיס T4/A100). הרץ את השרת כ-API תואם OpenAI באמצעות הפקודה הבאה:

python -m vllm.entrypoints.openai.api_server --model facebook/opt-125m

לאחר מכן, שלח בקשת POST פשוטה באמצעות curl או ספריית openai הרשמית ובדוק את מהירות התגובה (Tokens per second) בהשוואה להרצה רגילה.

בעולם ה-AI המתפתח במהירות מסחררת, בחירת מודל השפה (LLM) המתאים ביותר למשימה שלכם היא אתגר מורכב. כאן נכנסים לתמונה לוחות מובילים (Leaderboards) ומבחני ביצועים (Benchmarks). כלים אלו מספקים מדדים אובייקטיביים והשוואתיים בין עשרות ומאות מודלים שונים. שלושת הכלים המובילים כיום בתחום הם LMSYS Chatbot Arena (LMArena) המבוסס על דירוג אנושי עיוור (Elo rating), ה-Open LLM Leaderboard של Hugging Face המתמקד במבחנים אקדמיים פתוחים, ו-ArtificialAnalysis המספק ניתוח מעמיק של מהירות, עלות וביצועים בזמן אמת.

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

מעבר להסתמכות על לוחות ציבוריים, לעיתים קרובות תרצו להריץ מבחני ביצועים (benchmarks) מותאמים אישית על המודלים שלכם או על משימות ספציפיות לארגון שלכם. הכלי המוביל בתעשייה למטרה זו הוא lm-evaluation-harness של EleutherAI. כלי זה מאפשר להריץ מאות מבחנים סטנדרטיים (כמו MMLU, GSM8k ועוד) על כל מודל מקומי או מרוחק בצורה פשוטה ומהירה, ובכך לייצר "לוח מובילים" פנימי משלכם.

כדי להתחיל להשתמש ב-lm-evaluation-harness באופן מקומי, ניתן להריץ פקודה פשוטה מהטרמינל כדי להעריך מודל (למשל מודל של Hugging Face) על משימה ספציפית:

# התקנת הכלי
pip install lm-eval

# הרצת הערכה למודל Llama-3 על משימת MMLU
lm_eval --model hf \
    --model_args pretrained=meta-llama/Meta-Llama-3-8B \
    --tasks mmlu \
    --device cuda:0 \
    --batch_size 8

כאשר בונים מערכות AI מורכבות, כלי הערכה משתלבים ישירות בתוך ספריות הפיתוח. לדוגמה, בגרסאות האחרונות של DSPy 3.2.0 ו-DSPy 3.1.0, מושם דגש רב על אופטימיזציה והערכה אוטומטית של פרומפטים ומודלים (Assertions & Suggestions). שילוב של ספריות אלו יחד עם מתודולוגיות הערכה מובנות מאפשר לשפר את דיוק המודל בצורה שיטתית ומדידה, בדומה לתהליכי בדיקות תוכנה מסורתיים (CI/CD).

הצעד הבא שלכם: התקינו את פרויקט הקוד lm-evaluation-harness והריצו הערכה בסיסית על מודל קטן ופתוח (כמו Qwen/Qwen2.5-1.5B-Instruct) באמצעות משימת הערכה פשוטה כמו arc_challenge או hellaswag. השוו את התוצאות שקיבלתם לדירוג הרשמי ב-Open LLM Leaderboard כדי להבין כיצד המדדים מתנהגים בפועל.

בעולם ה-AI המתפתח במהירות מסחררת, בחירת מודל השפה (LLM) המתאים ביותר למשימה שלכם היא אתגר מורכב. כאן נכנסים לתמונה לוחות מובילים (Leaderboards) ומבחני ביצועים (Benchmarks). כלים אלו מספקים מדדים אובייקטיביים והשוואתיים בין עשרות ומאות מודלים שונים. שלושת הכלים המובילים כיום בתחום הם LMSYS Chatbot Arena (LMArena) המבוסס על דירוג אנושי עיוור (Elo rating), ה-Open LLM Leaderboard של Hugging Face המתמקד במבחנים אקדמיים פתוחים, ו-ArtificialAnalysis המספק ניתוח מעמיק של מהירות, עלות וביצועים בזמן אמת.

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

מעבר להסתמכות על לוחות ציבוריים, לעיתים קרובות תרצו להריץ מבחני ביצועים (benchmarks) מותאמים אישית על המודלים שלכם או על משימות ספציפיות לארגון שלכם. הכלי המוביל בתעשייה למטרה זו הוא lm-evaluation-harness של EleutherAI. כלי זה מאפשר להריץ מאות מבחנים סטנדרטיים (כמו MMLU, GSM8k ועוד) על כל מודל מקומי או מרוחק בצורה פשוטה ומהירה, ובכך לייצר "לוח מובילים" פנימי משלכם.

כדי להתחיל להשתמש ב-lm-evaluation-harness באופן מקומי, ניתן להריץ פקודה פשוטה מהטרמינל כדי להעריך מודל (למשל מודל של Hugging Face) על משימה ספציפית:

# התקנת הכלי
pip install lm-eval

# הרצת הערכה למודל Llama-3 על משימת MMLU
lm_eval --model hf \
    --model_args pretrained=meta-llama/Meta-Llama-3-8B \
    --tasks mmlu \
    --device cuda:0 \
    --batch_size 8

כאשר בונים מערכות AI מורכבות, כלי הערכה משתלבים ישירות בתוך ספריות הפיתוח. לדוגמה, בגרסאות האחרונות של DSPy 3.2.0 ו-DSPy 3.1.0, מושם דגש רב על אופטימיזציה והערכה אוטומטית של פרומפטים ומודלים (Assertions & Suggestions). שילוב של ספריות אלו יחד עם מתודולוגיות הערכה מובנות מאפשר לשפר את דיוק המודל בצורה שיטתית ומדידה, בדומה לתהליכי בדיקות תוכנה מסורתיים (CI/CD).

הצעד הבא שלכם: התקינו את פרויקט הקוד lm-evaluation-harness והריצו הערכה בסיסית על מודל קטן ופתוח (כמו Qwen/Qwen2.5-1.5B-Instruct) באמצעות משימת הערכה פשוטה כמו arc_challenge או hellaswag. השוו את התוצאות שקיבלתם לדירוג הרשמי ב-Open LLM Leaderboard כדי להבין כיצד המדדים מתנהגים בפועל.

בעולם ה-AI המודרני, מודלים של שפה כבר אינם מוגבלים לטקסט בלבד. מודלים רב-מודאליים (Multimodal Models) בקוד פתוח, כדוגמת Llama 3.2 Vision, Qwen-VL ו-PaliGemma, חוללו מהפכה בכך שהם מאפשרים ל-LLM "לראות" תמונות ווידאו, ואף להבין אודיו באותה רשת נוירונים. פריצת הדרך הזו מתאפשרת על ידי חיבור של Vision Encoder (כמו CLIP או SigLIP) ישירות אל ה-Backbone של מודל השפה באמצעות שכבת קישור (Projection Layer) המתרגמת את הפיצ'רים הוויזואליים לטוקנים שהמודל מסוגל לעבד.

המעבר למודלים רב-מודאליים בקוד פתוח (Open-Source) הוא קריטי עבור ארגונים ומפתחים המעוניינים בפרטיות מידע מלאה, התאמה אישית (Fine-tuning) על דאטה ייחודי, ומניעת עלויות API גבוהות של מודלים סגורים. שימוש במודלים אלו נפוץ במיוחד במערכות RAG מתקדמות המשלבות מסמכים סרוקים, ניתוח אוטומטי של תרשימים רפואיים, פענוח קבלות (OCR מתקדם), ואפילו ניתוח בזמן אמת של מצלמות אבטחה ווידאו.

כדי לבנות יישומים מורכבים המשלבים ראייה ממוחשבת ושפה, אנו נעזרים בפריימוורקים מובילים לניהול קונטקסט. עדכונים אחרונים כמו LlamaIndex v0.14.15 וכן llama-index-core 0.14.16 מציגים שיפורים משמעותיים בתמיכה במודלי Vision, המאפשרים שליפת מידע מדויקת מתוך תמונות ומסמכים מרובי עמודים (Multi-modal RAG).

להלן דוגמה קונקרטית לטעינה והרצה של מודל Qwen-VL לניתוח תמונה באמצעות ספריית transformers של Hugging Face:

from transformers import Qwen2VLForConditionalGeneration, AutoProcessor
from PIL import Image

# טעינת המודל והמעבד המתאים
model = Qwen2VLForConditionalGeneration.from_pretrained("Qwen/Qwen2-VL-7B-Instruct", torch_dtype="auto", device_map="auto")
processor = AutoProcessor.from_pretrained("Qwen/Qwen2-VL-7B-Instruct")

image = Image.open("invoice.jpg")
messages = [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "Extract the total amount and tax from this invoice."}]}]
text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = processor(text=[text], images=[image], padding=True, return_tensors="pt").to("cuda")

generated_ids = model.generate(**inputs, max_new_tokens=128)
print(processor.batch_decode(generated_ids, skip_special_tokens=True))

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

הצעד הבא שלכם: פרויקט הסטארטר המומלץ ביותר להתחלה הוא שימוש ב- LLaVA או ב- Qwen-VL. הורידו את אחד המודלים הללו באופן מקומי (למשל באמצעות Ollama או Hugging Face), והקימו יישום קטן שמקבל קובץ PDF סרוק ומפיק ממנו קובץ JSON מובנה המכיל את כל הנתונים החשובים מתוך הטבלאות והגרפים שבו.

בעולם ה-AI המודרני, מודלים של שפה כבר אינם מוגבלים לטקסט בלבד. מודלים רב-מודאליים (Multimodal Models) בקוד פתוח, כדוגמת Llama 3.2 Vision, Qwen-VL ו-PaliGemma, חוללו מהפכה בכך שהם מאפשרים ל-LLM "לראות" תמונות ווידאו, ואף להבין אודיו באותה רשת נוירונים. פריצת הדרך הזו מתאפשרת על ידי חיבור של Vision Encoder (כמו CLIP או SigLIP) ישירות אל ה-Backbone של מודל השפה באמצעות שכבת קישור (Projection Layer) המתרגמת את הפיצ'רים הוויזואליים לטוקנים שהמודל מסוגל לעבד.

המעבר למודלים רב-מודאליים בקוד פתוח (Open-Source) הוא קריטי עבור ארגונים ומפתחים המעוניינים בפרטיות מידע מלאה, התאמה אישית (Fine-tuning) על דאטה ייחודי, ומניעת עלויות API גבוהות של מודלים סגורים. שימוש במודלים אלו נפוץ במיוחד במערכות RAG מתקדמות המשלבות מסמכים סרוקים, ניתוח אוטומטי של תרשימים רפואיים, פענוח קבלות (OCR מתקדם), ואפילו ניתוח בזמן אמת של מצלמות אבטחה ווידאו.

כדי לבנות יישומים מורכבים המשלבים ראייה ממוחשבת ושפה, אנו נעזרים בפריימוורקים מובילים לניהול קונטקסט. עדכונים אחרונים כמו LlamaIndex v0.14.15 וכן llama-index-core 0.14.16 מציגים שיפורים משמעותיים בתמיכה במודלי Vision, המאפשרים שליפת מידע מדויקת מתוך תמונות ומסמכים מרובי עמודים (Multi-modal RAG).

להלן דוגמה קונקרטית לטעינה והרצה של מודל Qwen-VL לניתוח תמונה באמצעות ספריית transformers של Hugging Face:

from transformers import Qwen2VLForConditionalGeneration, AutoProcessor
from PIL import Image

# טעינת המודל והמעבד המתאים
model = Qwen2VLForConditionalGeneration.from_pretrained("Qwen/Qwen2-VL-7B-Instruct", torch_dtype="auto", device_map="auto")
processor = AutoProcessor.from_pretrained("Qwen/Qwen2-VL-7B-Instruct")

image = Image.open("invoice.jpg")
messages = [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "Extract the total amount and tax from this invoice."}]}]
text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = processor(text=[text], images=[image], padding=True, return_tensors="pt").to("cuda")

generated_ids = model.generate(**inputs, max_new_tokens=128)
print(processor.batch_decode(generated_ids, skip_special_tokens=True))

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

הצעד הבא שלכם: פרויקט הסטארטר המומלץ ביותר להתחלה הוא שימוש ב- LLaVA או ב- Qwen-VL. הורידו את אחד המודלים הללו באופן מקומי (למשל באמצעות Ollama או Hugging Face), והקימו יישום קטן שמקבל קובץ PDF סרוק ומפיק ממנו קובץ JSON מובנה המכיל את כל הנתונים החשובים מתוך הטבלאות והגרפים שבו.

להריץ מודל שפה ענק של 70 מיליארד פרמטרים (70B) על מחשב נייד אישי נשמע בעבר כמו מדע בדיוני. מודל כזה בפורמט FP16 (דיוק של 16-bit) דורש מעל 140GB של זיכרון VRAM/RAM רק כדי להיטען. כאן נכנסת לתמונה טכנולוגיית ה-Quantization (כימות), המאפשרת לדחוס את משקולות המודל ל-4-bit או 8-bit, ובכך להפחית את דרישות הזיכרון בכ-75% תוך שמירה על ביצועים קרובים מאוד למקור. פריצת הדרך הזו מאפשרת להריץ מודלים מקומיים חזקים ישירות על חומרת קצה, כפי שמתואר בדיון על יצירת עוזר AI פרטי ב-Thunderbird.

הפורמט הפופולרי ביותר להרצה מקומית על מעבדים (CPU) ומעבדי Apple Silicon הוא GGUF, שפותח כחלק מפרויקט llama.cpp. GGUF מותאם במיוחד להרצה יעילה תוך שיתוף זיכרון בין ה-CPU ל-GPU (במיוחד ב-MacBook עם Unified Memory). הוא תומך בטכניקות כימות מתקדמות (כמו k-quants) המאפשרות להריץ מודל 70B בכימות של 4-bit (הדורש כ-40GB RAM בלבד) במהירות סבירה לחלוטין לשימוש יומיומי.

עבור שרתי GPU ומשימות הדורשות מהירות הפקה (throughput) גבוהה, אנו משתמשים בפורמטים כמו GPTQ ו-AWQ. בעוד ש-GPTQ מבצע כימות סטטי המבוסס על כיול חד-פעמי, שיטת AWQ (Activation-aware Weight Quantization), הנתמכת על ידי ספריות כמו AutoAWQ, מגינה על משקולות קריטיות ("salient weights") שמושפעות ביותר בזמן ה-activation. גישה זו שומרת על דיוק גבוה משמעותית בכימות של 4-bit, ומאפשרת אינטגרציה חלקה עם מנועי הרצה מהירים כמו vLLM ו-Hugging Face.

הבחירה בין השיטות תלויה בחומרה ובשימוש: GGUF הוא המלך הבלתי מעורער של הרצה מקומית על מחשבים ניידים ומעבדים משולבים. AWQ ו-GPTQ מיועדים ל-GPUs ייעודיים (כמו כרטיסי Nvidia RTX) ומספקים מהירות הפקה גבוהה בהרבה בסביבות פרודקשן. הירידה באיכות (Perplexity) במעבר ל-4-bit היא מינורית ביותר ברוב המשימות, מה שהופך את הוויתור על הדיוק המלא למשתלם במיוחד במאבק בין האגדה על מלחמות המודלים: פתוח vs סגור ב-2026.

להלן דוגמה פשוטה להרצת מודל Llama 3 8B בפורמט GGUF מקומית באמצעות Python וספריית llama-cpp-python:

from llama_cpp import Llama

# טעינת מודל GGUF שעבר כימות ל-4-bit
llm = Llama(
    model_path="./llama-3-8b-Instruct-Q4_K_M.gguf",
    n_ctx=2048,  # אורך ההקשר
    n_threads=8  # מספר ליבות ה-CPU לשימוש
)

# הרצת פרומפט
output = llm("Q: What is the benefit of AWQ over GPTQ? A:", max_tokens=100)
print(output["choices"][0]["text"])

הצעד הבא שלכם: הורידו את כלי ה-CLI של llama.cpp, הורידו מודל Llama 3 8B בפורמט GGUF (למשל גרסת Q4_K_M מ-Hugging Face), והריצו אותו מקומית דרך הטרמינל שלכם. זו הדרך המהירה ביותר להבין את העוצמה של מודלים מכומתים על המחשב האישי שלכם.

להריץ מודל שפה ענק של 70 מיליארד פרמטרים (70B) על מחשב נייד אישי נשמע בעבר כמו מדע בדיוני. מודל כזה בפורמט FP16 (דיוק של 16-bit) דורש מעל 140GB של זיכרון VRAM/RAM רק כדי להיטען. כאן נכנסת לתמונה טכנולוגיית ה-Quantization (כימות), המאפשרת לדחוס את משקולות המודל ל-4-bit או 8-bit, ובכך להפחית את דרישות הזיכרון בכ-75% תוך שמירה על ביצועים קרובים מאוד למקור. פריצת הדרך הזו מאפשרת להריץ מודלים מקומיים חזקים ישירות על חומרת קצה, כפי שמתואר בדיון על יצירת עוזר AI פרטי ב-Thunderbird.

הפורמט הפופולרי ביותר להרצה מקומית על מעבדים (CPU) ומעבדי Apple Silicon הוא GGUF, שפותח כחלק מפרויקט llama.cpp. GGUF מותאם במיוחד להרצה יעילה תוך שיתוף זיכרון בין ה-CPU ל-GPU (במיוחד ב-MacBook עם Unified Memory). הוא תומך בטכניקות כימות מתקדמות (כמו k-quants) המאפשרות להריץ מודל 70B בכימות של 4-bit (הדורש כ-40GB RAM בלבד) במהירות סבירה לחלוטין לשימוש יומיומי.

עבור שרתי GPU ומשימות הדורשות מהירות הפקה (throughput) גבוהה, אנו משתמשים בפורמטים כמו GPTQ ו-AWQ. בעוד ש-GPTQ מבצע כימות סטטי המבוסס על כיול חד-פעמי, שיטת AWQ (Activation-aware Weight Quantization), הנתמכת על ידי ספריות כמו AutoAWQ, מגינה על משקולות קריטיות ("salient weights") שמושפעות ביותר בזמן ה-activation. גישה זו שומרת על דיוק גבוה משמעותית בכימות של 4-bit, ומאפשרת אינטגרציה חלקה עם מנועי הרצה מהירים כמו vLLM ו-Hugging Face.

הבחירה בין השיטות תלויה בחומרה ובשימוש: GGUF הוא המלך הבלתי מעורער של הרצה מקומית על מחשבים ניידים ומעבדים משולבים. AWQ ו-GPTQ מיועדים ל-GPUs ייעודיים (כמו כרטיסי Nvidia RTX) ומספקים מהירות הפקה גבוהה בהרבה בסביבות פרודקשן. הירידה באיכות (Perplexity) במעבר ל-4-bit היא מינורית ביותר ברוב המשימות, מה שהופך את הוויתור על הדיוק המלא למשתלם במיוחד במאבק בין האגדה על מלחמות המודלים: פתוח vs סגור ב-2026.

להלן דוגמה פשוטה להרצת מודל Llama 3 8B בפורמט GGUF מקומית באמצעות Python וספריית llama-cpp-python:

from llama_cpp import Llama

# טעינת מודל GGUF שעבר כימות ל-4-bit
llm = Llama(
    model_path="./llama-3-8b-Instruct-Q4_K_M.gguf",
    n_ctx=2048,  # אורך ההקשר
    n_threads=8  # מספר ליבות ה-CPU לשימוש
)

# הרצת פרומפט
output = llm("Q: What is the benefit of AWQ over GPTQ? A:", max_tokens=100)
print(output["choices"][0]["text"])

הצעד הבא שלכם: הורידו את כלי ה-CLI של llama.cpp, הורידו מודל Llama 3 8B בפורמט GGUF (למשל גרסת Q4_K_M מ-Hugging Face), והריצו אותו מקומית דרך הטרמינל שלכם. זו הדרך המהירה ביותר להבין את העוצמה של מודלים מכומתים על המחשב האישי שלכם.

מערכת RAG (Retrieval-Augmented Generation) מקומית לחלוטין מאפשרת לנו לבנות יישומי בינה מלאכותית חכמים המבוססים על המידע הפרטי שלנו, מבלי לשלוח אף פיסת מידע לענן. השילוב בין Ollama (להרצת מודלי שפה ומודלי Embeddings מקומיים) לבין Chroma (מסד נתונים וקטורי קל ומהיר) מייצר סביבת עבודה עצמאית לחלוטין, הפועלת ישירות על המחשב האישי שלכם.

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

כדי להקים מערכת כזו, אנו משתמשים ב-Ollama כדי להריץ מודל שפה (כמו Llama 3) ומודל ייצוג וקטורי (Embedding). הטקסטים שלנו עוברים תהליך של "צ'אנקניג" (פירוק למקטעים), מומרים לווקטורים באמצעות מודל ה-Embedding, ונשמרים בתוך Chroma DB. כאשר המשתמש שואל שאלה, השאלה מומרת לווקטור, Chroma שולף את המקטעים הרלוונטיים ביותר, ואלו נשלחים יחד עם השאלה כהקשר (Context) למודל השפה המקומי ב-Ollama שמייצר את התשובה הסופית.

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

import chromadb
from chromadb.utils import embedding_functions

# חיבור ל-Chroma מקומי והגדרת מודל Embedding של Ollama
client = chromadb.PersistentClient(path="./chroma_db")
ollama_ef = embedding_functions.OllamaEmbeddingFunction(
    url="http://localhost:11434/api/embeddings",
    model_name="nomic-embed-text"
)
collection = client.get_or_create_collection(name="local_docs", embedding_function=ollama_ef)

# הוספת מסמכים ואחזור
collection.add(documents=["Ollama runs LLMs locally", "Chroma is a vector database"], ids=["id1", "id2"])
results = collection.query(query_texts=["What is Chroma?"], n_results=1)
print(results["documents"])

הצעד הבא שלכם הוא להתקין את Ollama על המחשב, להוריד מודל כמו llama3 ומודל embedding כמו nomic-embed-text. לאחר מכן, מומלץ להוריד ולהריץ את פרויקט הקוד Ollama + Chroma כדי לראות את המערכת בפעולה, או להשתמש ב-LlamaIndex כדי לבנות צינורות RAG מתקדמים ומורכבים יותר בקלות.

מערכת RAG (Retrieval-Augmented Generation) מקומית לחלוטין מאפשרת לנו לבנות יישומי בינה מלאכותית חכמים המבוססים על המידע הפרטי שלנו, מבלי לשלוח אף פיסת מידע לענן. השילוב בין Ollama (להרצת מודלי שפה ומודלי Embeddings מקומיים) לבין Chroma (מסד נתונים וקטורי קל ומהיר) מייצר סביבת עבודה עצמאית לחלוטין, הפועלת ישירות על המחשב האישי שלכם.

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

כדי להקים מערכת כזו, אנו משתמשים ב-Ollama כדי להריץ מודל שפה (כמו Llama 3) ומודל ייצוג וקטורי (Embedding). הטקסטים שלנו עוברים תהליך של "צ'אנקניג" (פירוק למקטעים), מומרים לווקטורים באמצעות מודל ה-Embedding, ונשמרים בתוך Chroma DB. כאשר המשתמש שואל שאלה, השאלה מומרת לווקטור, Chroma שולף את המקטעים הרלוונטיים ביותר, ואלו נשלחים יחד עם השאלה כהקשר (Context) למודל השפה המקומי ב-Ollama שמייצר את התשובה הסופית.

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

import chromadb
from chromadb.utils import embedding_functions

# חיבור ל-Chroma מקומי והגדרת מודל Embedding של Ollama
client = chromadb.PersistentClient(path="./chroma_db")
ollama_ef = embedding_functions.OllamaEmbeddingFunction(
    url="http://localhost:11434/api/embeddings",
    model_name="nomic-embed-text"
)
collection = client.get_or_create_collection(name="local_docs", embedding_function=ollama_ef)

# הוספת מסמכים ואחזור
collection.add(documents=["Ollama runs LLMs locally", "Chroma is a vector database"], ids=["id1", "id2"])
results = collection.query(query_texts=["What is Chroma?"], n_results=1)
print(results["documents"])

הצעד הבא שלכם הוא להתקין את Ollama על המחשב, להוריד מודל כמו llama3 ומודל embedding כמו nomic-embed-text. לאחר מכן, מומלץ להוריד ולהריץ את פרויקט הקוד Ollama + Chroma כדי לראות את המערכת בפעולה, או להשתמש ב-LlamaIndex כדי לבנות צינורות RAG מתקדמים ומורכבים יותר בקלות.