למידת מכונה בשנת 2026: מה באמת צריך לדעת

התשובה הקצרה: למידת מכונה (Machine Learning) היא לא קסם ולא מילת באזז — היא מיומנות הנדסית שאפשר לרכוש, גם בלי תואר שני, גם בלי GPU מפלצתי בבית. מה שצריך? הבנה מוצקה של מתמטיקה בסיסית, יכולת לכתוב קוד נקי ב-Python, וגישה ביקורתית לנתונים. מי שמתחיל היום עם הכלים הנכונים והתרגול הנכון — יכול תוך שנה לבנות מודלים שפותרים בעיות אמיתיות. לא מדובר בהבטחה ריקה; מדובר במציאות שאנחנו רואים כל יום אצל אנשים שנכנסו לתחום בלי רקע אקדמי קלאסי וכיום עובדים בחברות מהשורה הראשונה בישראל. המאמר הזה לא ילטף אתכם — הוא ייתן לכם מפה אמיתית.

כשרוב האנשים שומעים "למידת מכונה", הם חושבים על רובוטים שמדברים או על ChatGPT. זה כמו לחשוב שפיזיקה זה רק טילים לחלל. למידת מכונה היא ענף של בינה מלאכותית (Artificial Intelligence) שבו אלגוריתמים לומדים דפוסים מתוך נתונים — בלי שמישהו כותב להם כללים מפורשים.

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

שלוש הפרדיגמות שחייבים להכיר

למידה מפוקחת (Supervised Learning) — המודל מקבל דוגמאות עם תוויות (labels). למשל: תמונות של חתולים וכלבים, כל אחת מסומנת. המודל לומד לסווג תמונות חדשות לבד. לפי סקר של Kaggle בשנת 2024, כ-78% מפרויקטי ה-ML בתעשייה משתמשים בלמידה מפוקחת כשלב מרכזי.

למידה לא מפוקחת (Unsupervised Learning) — אין תוויות. המודל מחפש דפוסים, אשכולות, מבנים חבויים. נפוץ באיתור הונאות ובסגמנטציית לקוחות.

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

למה זה רלוונטי לשוק הישראלי — עכשיו

ישראל היא מעצמת סטארטאפים, וזה לא קלישאה — זו סטטיסטיקה. לפי דו"ח IVC לשנת 2024, למעלה מ-35% מהסטארטאפים הישראליים שגייסו כסף בשנה האחרונה משלבים ML כמרכיב ליבה במוצר. חברות כמו Mobileye, Hailo, Run:ai ו-AI21 Labs הן רק קצה הקרחון.

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

בואו נהיה ישירים: אחת הטעויות הנפוצות של מי שנכנס לתחום היא לנסות ללמוד הכל בו-זמנית. Python, R, Julia, TensorFlow, PyTorch, scikit-learn, Keras, JAX, HuggingFace, LangChain — הרשימה אינסופית. ואם לא תבחרו מסלול, תתקעו.

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

Python — אין עליה ואין תחליף (בינתיים)

Python היא השפה הדומיננטית בעולם ה-ML ואין סימן שזה משתנה בקרוב. לפי מדד TIOBE של ינואר 2025, Python ממשיכה להחזיק את המקום הראשון כשפת התכנות הפופולרית בעולם, עם נתח של מעל 16%. בעולם ה-Data Science ו-ML, הדומיננטיות שלה אפילו גדולה יותר.

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

המסגרות שצריך להכיר — לפי שלב

למתחילים: scikit-learn. ספרייה מבוססת, יציבה, מתועדת להפליא. מאפשרת לבנות מודלים קלאסיים — רגרסיה, סיווג, אשכולות — בכמה שורות קוד. זו לא צעצוע; רוב הפרויקטים בתעשייה מתחילים ב-scikit-learn לפני שמעבירים ל-Deep Learning.

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

ל-Deployment: TensorFlow Lite (עבור Edge AI ומערכות משובצות), ONNX Runtime (להרצה חוצת-פלטפורמות), ו-FastAPI או Flask לבניית API שמגיש תחזיות בזמן אמת.

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

הנה דוגמה מלאה ועובדת. ניקח את מערך הנתונים הקלאסי Iris (מערך של 150 פרחים עם 4 מאפיינים כל אחד, מחולקים ל-3 מינים), נבנה מודל סיווג פשוט, נעריך אותו, ונבין מה קורה מאחורי הקלעים.

הכנת הסביבה

לפני הכל — צריך סביבת עבודה נקייה. תמיד עדיף לעבוד ב-virtual environment כדי לא ליצור קונפליקטים בין ספריות:

# יצירת סביבה וירטואלית חדשה
python3 -m venv ml-env
source ml-env/bin/activate

# התקנת הספריות הנדרשות
pip install scikit-learn pandas numpy matplotlib seaborn

# בדיקה שהכל עובד
python3 -c "import sklearn; print(f'scikit-learn version: {sklearn.__version__}')"

בניית מודל סיווג מלא

עכשיו נכתוב את הקוד עצמו. שימו לב — כל שורה מוסברת. זה לא קוד שמעתיקים בלי להבין; זה קוד שלומדים ממנו:

import numpy as np
import pandas as pd
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns

# --- שלב 1: טעינת הנתונים ---
iris = load_iris()
X = pd.DataFrame(iris.data, columns=iris.feature_names)
y = pd.Series(iris.target, name='species')

print("צורת הנתונים:", X.shape)
print("התפלגות המחלקות:")
print(y.value_counts())

# --- שלב 2: חלוקה לסט אימון וסט מבחן ---
# 80% אימון, 20% מבחן. stratify שומר על יחס המחלקות
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# --- שלב 3: נרמול (Scaling) ---
# Random Forest לא חייב נרמול, אבל זה הרגל טוב
# ואלגוריתמים אחרים (SVM, KNN) דורשים את זה
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)  # רק transform, לא fit!

# --- שלב 4: בניית המודל ---
model = RandomForestClassifier(
    n_estimators=100,       # 100 עצי החלטה
    max_depth=5,            # עומק מקסימלי לכל עץ
    random_state=42,
    n_jobs=-1               # ניצול כל הליבות
)
model.fit(X_train_scaled, y_train)

# --- שלב 5: הערכה ---
y_pred = model.predict(X_test_scaled)

print("\n--- דוח סיווג ---")
print(classification_report(
    y_test, y_pred, 
    target_names=iris.target_names
))

# --- שלב 6: Cross-Validation ---
# הערכה יציבה יותר מחלוקה בודדת
cv_scores = cross_val_score(model, X_train_scaled, y_train, cv=5)
print(f"Cross-Validation Accuracy: {cv_scores.mean():.3f} (+/- {cv_scores.std():.3f})")

# --- שלב 7: חשיבות המשתנים ---
feature_importance = pd.Series(
    model.feature_importances_, 
    index=iris.feature_names
).sort_values(ascending=False)

print("\nחשיבות המשתנים:")
print(feature_importance)

# --- שלב 8: Confusion Matrix ויזואלית ---
cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
            xticklabels=iris.target_names,
            yticklabels=iris.target_names)
plt.title('Confusion Matrix')
plt.ylabel('True Label')
plt.xlabel('Predicted Label')
plt.tight_layout()
plt.savefig('confusion_matrix.png', dpi=150)
plt.show()

שימו לב למספר נקודות קריטיות בקוד הזה. ראשית, ב-שלב 3 השתמשנו ב-fit_transform על סט האימון אבל רק transform על סט המבחן. זה אחד הבאגים הנפוצים ביותר בקרב מתחילים — אם עושים fit גם על סט המבחן, אתם "מדליפים" מידע מסט המבחן לתהליך האימון (Data Leakage), והתוצאות שלכם יהיו אופטימיות מדי.

שנית, Cross-Validation (שלב 6) הוא חיוני. חלוקה בודדת לאימון ומבחן יכולה לתת תוצאות מטעות בגלל מזל. חמש חלוקות שונות נותנות תמונה מהימנה הרבה יותר.

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

טעות מספר 1: לקפוץ ל-Deep Learning לפני שמבינים את הבסיס

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

כלל אצבע שעובד: אם אתם לא יכולים להסביר למישהו שלא מהתחום למה המודל שלכם עושה מה שהוא עושה — אתם לא מספיק מבינים. ו-Deep Learning מקשה מאוד על הסברים כאלה. התחילו עם scikit-learn, תבינו כל פרמטר, כל מדד, כל החלטה. רק אז תעברו ל-PyTorch.

טעות מספר 2: להזניח את הנתונים

יש אמרה ישנה בתחום: "Garbage in, garbage out". היא נכונה כמו ביום שנאמרה לראשונה. לפי מחקר של MIT משנת 2023, כ-65% מהזמן בפרויקט ML טיפוסי מוקדש להכנת נתונים — ניקוי, תיוג, נרמול, הנדסת מאפיינים (Feature Engineering). רק 15%-20% מוקדשים לבניית המודל עצמו.

ובכל זאת, רוב הקורסים ורוב המתחילים מבלים 90% מהזמן על המודל ו-10% על הנתונים. הפוך. מודל פשוט עם נתונים נקיים יכה מודל מורכב עם נתונים מלוכלכים — כמעט תמיד.

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

זו הטעות שהכי כואבת כי היא מתגלה הכי מאוחר. בניתם מודל מדהים ב-Jupyter Notebook, הוא מראה 97% דיוק, ואז מנסים להעביר אותו ל-Production — ושום דבר לא עובד. הנתונים בעולם האמיתי נראים שונה, התשתית לא תומכת, הביצועים איטיים.

המושג MLOps קיים בדיוק בשביל זה: לגשר בין המעבדה לעולם האמיתי. כלים כמו MLflow (למעקב אחר ניסויים), DVC (לניהול גרסאות נתונים), ו-Docker/Kubernetes (לפריסה) הם חלק בלתי נפרד מערכת הכישורים של מהנדס/ת ML מודרני/ת.

בואו נדבר תכל'ס. הרבה אנשים שואלים: "מה אני צריך לדעת כדי למצוא עבודה?" התשובה משתנה לפי התפקיד, אבל יש ליבה משותפת.

Data Scientist לעומת ML Engineer — מה ההבדל?

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

ML Engineer מתמקד בלקחת את המודלים האלה ולהריץ אותם בקנה מידה (scale). זה תפקיד שדורש יותר הנדסת תוכנה — Docker, CI/CD, APIs, מערכות מבוזרות. לפי נתוני LinkedIn Israel מ-2024, הביקוש לתפקידי ML Engineer בישראל עלה ב-47% בהשוואה לשנה קודמת.

הכישורים שהשוק הישראלי דורש בשנת 2025

אחרי שסרקנו מאות משרות פתוחות בחברות ישראליות — מסטארטאפים ועד חברות כמו Wix, Monday.com, Check Point ו-Intel Israel — הנה מה שחוזר שוב ושוב:

Python חזק (כולל OOP ולא רק notebooks). ניסיון עם PyTorch או TensorFlow. הבנה של SQL ועבודה עם מסדי נתונים. היכרות עם Cloud (AWS SageMaker, GCP Vertex AI, או Azure ML). יסודות של Docker ו-Git. ומעל הכל — היכולת לקחת בעיה עסקית ולתרגם אותה לבעיית ML. זה הכישור שמפריד בין ג'וניור למישהו שמקבל עבודה.

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

למה זה משנה את כללי המשחק

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

חברות ישראליות כמו Hailo מפתחות שבבים ייעודיים ל-Edge AI שמריצים רשתות נוירונים בביצועים מטורפים בצריכת חשמל מינימלית. Brodmann17 (שנרכשה על ידי LTTS) פיתחה ארכיטקטורות רשת שמותאמות במיוחד לחומרה חלשה. זה שדה שצומח במהירות, ומי שמבין גם ML וגם מערכות משובצות — שווה זהב.

דוגמה מעשית: הרצת מודל על Raspberry Pi

הנה תהליך מעשי להמרת מודל PyTorch ל-TensorFlow Lite והרצתו על מכשיר Edge:

# התקנת הכלים הנדרשים על Raspberry Pi
pip install tflite-runtime numpy pillow

# המרת מודל PyTorch ל-ONNX ומשם ל-TFLite (על מחשב הפיתוח)
pip install torch onnx onnx-tf tensorflow

# שלב 1: ייצוא מ-PyTorch ל-ONNX
python3 -c "
import torch
import torchvision.models as models

# טעינת מודל מאומן (MobileNetV2 — קל ומהיר)
model = models.mobilenet_v2(pretrained=True)
model.eval()

# יצירת קלט דמה
dummy_input = torch.randn(1, 3, 224, 224)

# ייצוא ל-ONNX
torch.onnx.export(model, dummy_input, 'mobilenet_v2.onnx',
                  input_names=['input'], output_names=['output'],
                  dynamic_axes={'input': {0: 'batch'}, 'output': {0: 'batch'}})
print('ONNX export done!')
"

# שלב 2: המרה ל-TFLite (על מחשב הפיתוח)
python3 -c "
import tensorflow as tf

# המרה מ-SavedModel ל-TFLite עם קוונטיזציה
converter = tf.lite.TFLiteConverter.from_saved_model('saved_model_dir')
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.supported_types = [tf.float16]
tflite_model = converter.convert()

with open('mobilenet_v2_fp16.tflite', 'wb') as f:
    f.write(tflite_model)
print(f'TFLite model size: {len(tflite_model) / 1024 / 1024:.1f} MB')
"

הקוונטיזציה (Quantization) בשלב 2 היא המפתח. היא מקטינה את המודל פי 2-4 ומאיצה את ההרצה, עם ירידה מינימלית בדיוק. זה ההבדל בין מודל שלא ירוץ על Raspberry Pi למודל שירוץ בזמן אמת.

העולם של ML לא עומד במקום — הוא דוהר. הנה שלושה טרנדים שכדאי לשים עליהם עין:

Small Language Models (SLMs): אחרי ההתלהבות ממודלים ענקיים כמו GPT-4, התעשייה מבינה שמודלים קטנים וממוקדים — כמו Phi-3 של Microsoft או Gemma של Google — פעמים רבות מספיקים ועולים הרבה פחות להרצה. הם מאפשרים הרצה מקומית, בלי תלות בענן.

Multimodal AI: מודלים שמבינים טקסט, תמונה, אודיו ווידאו ביחד. זה לא עתיד — זה הווה. GPT-4V, Gemini, LLaVA — כולם מולטימודליים. הביקוש למפתחים שיודעים לשלב מודאליות שונות הולך וגדל.

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

האם צריך תואר כדי לעבוד בלמידת מכונה?

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

מהי למידה עמוקה ומתי כדאי להשתמש בה?

למידה עמוקה (Deep Learning) היא תת-תחום של למידת מכונה שמבוסס על רשתות נוירונים עם שכבות רבות. היא מצטיינת בעיבוד תמונה, שפה טבעית, ואודיו. כדאי להשתמש בה כשיש הרבה נתונים (אלפי דוגמאות ומעלה), כשהבעיה מורכבת (למשל זיהוי אובייקטים בתמונה), וכשיש משאבי חישוב מספיקים. לבעיות פשוטות יותר עם מעט נתונים — אלגוריתמים קלאסיים מ-scikit-learn יתנו תוצאות טובות בהרבה פחות מאמץ.

כמה זמן לוקח ללמוד למידת מכונה?

תלוי ברקע ובמטרה. מישהו עם רקע בתכנות ובסיס מתמטי יכול להגיע ליכולת לבנות מודלים עובדים תוך 3-6 חודשים של לימוד מרוכז (10-15 שעות שבועיות). להגיע לרמה של מהנדס/ת ML בתעשייה — חשבו על 12-18 חודשים עם תרגול אינטנסיבי. הנקודה הקריטית: לא מספיק ללמוד — צריך לתרגל. לבנות פרויקטים, להשתתף בתחרויות Kaggle, לתרום לקוד פתוח.

מה ההבדל בין בינה מלאכותית ללמידת מכונה?

בינה מלאכותית (AI) היא התחום הרחב — כל מערכת שמחקה התנהגות אינטליגנטית. למידת מכונה (ML) היא תת-תחום של AI שבו המערכת לומדת מנתונים. למידה עמוקה (Deep Learning) היא תת-תחום של ML שמבוסס על רשתות נוירונים. חשבו על זה כמעגלים מקוננים: AI הוא המעגל הגדול, ML בתוכו, ו-DL בתוך ML. לא כל AI הוא ML (למשל, מערכת מומחה מבוססת כללים היא AI אבל לא ML), ולא כל ML הוא Deep Learning.

איזה מחשב צריך כדי לעבוד עם למידת מכונה?

למתחילים — כל מחשב נייד סביר מספיק. רוב הלמידה והתרגול הראשוני נעשים על מערכי נתונים קטנים שרצים ב-CPU תוך שניות. לעבודה עם Deep Learning ומערכי נתונים גדולים, כרטיס NVIDIA עם CUDA יעזור — אבל אפשר גם להשתמש בשירותי ענן חינמיים כמו Google Colab (שנותן GPU בחינם) או Kaggle Notebooks. אין שום סיבה ששיקול של חומרה יעצור אתכם מלהתחיל.

האם למידת מכונה רלוונטית רק לחברות הייטק גדולות?

ממש לא. בשנים האחרונות ML חודר לכל תעשייה. בישראל, חקלאות (Taranis, Prospera/Valmont), רפואה (Aidoc, Zebra Medical), פינטק (Pagaya, Lemonade), ביטחון (Rafael, Elbit), ואפילו ניהול מלונות ומסעדות. הדמוקרטיזציה של הכלים (ספריות חינמיות, ענן זמין, מודלים מאומנים מראש) מאפשרת גם לעסקים קטנים ליהנות מ-ML. הבעיה כבר לא טכנולוגית — היא מציאת האנשים שיודעים ליישם את הטכנולוגיה.

מה עדיף — PyTorch או TensorFlow?

בשנת 2025, PyTorch הוא הבחירה הראשונה לרוב המקרים. הוא דומיננטי במחקר (מעל 80% מהמאמרים ב-NeurIPS ו-ICML), הולך ותופס נתח גם בתעשייה, והאקוסיסטם סביבו (HuggingFace, Lightning, torchvision) עצום. TensorFlow עדיין חזק מאוד ב-Deployment, במיוחד עם TF Lite ל-Edge ו-TF.js לדפדפן. ההמלצה: התחילו עם PyTorch, ולימדו להמיר ל-TFLite כשצריך להריץ על מכשירים. ככה תכסו 95% מהתרחישים.

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

• קורס סייבר ואבטחת מידע
• קורס Real Time Embedded
• קורס דאטה סיינס
• קורס למידת מכונה AI
• קורס דאטה אנליסט
• קורס DEVOPS
• קורס IT
• קורס אוטומציה
• קורס Full Stack
• קורס בניית אתרים