Deep Learning למתחילים: מדריך מעשי עם קוד אמיתי

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

בואו נפתח בדוגרי: Deep Learning שינה את העולם. לא באופן מטאפורי — באופן ממשי. לפי דוח של McKinsey משנת 2023, טכנולוגיות בינה מלאכותית מבוססות למידה עמוקה צפויות לתרום 4.4 טריליון דולר לכלכלה העולמית בשנים הקרובות. וזה לא שם ברחוק — בישראל לבד פועלות למעלה מ-2,000 חברות סטארטאפ בתחום ה-AI וה-ML, לפי נתוני Start-Up Nation Central.

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

ההבדל בין Machine Learning ל-Deep Learning

Machine Learning (למידת מכונה) הוא התחום הרחב — כל אלגוריתם שמשתפר עם ניסיון. Deep Learning הוא תת-תחום שמשתמש ברשתות נוירונים עם הרבה שכבות (עמוקות — מכאן השם). ההבדל המעשי? באלגוריתמים "קלאסיים" של ML כמו Decision Trees או SVM, אתה צריך להגדיר ידנית אילו פיצ'רים (תכונות) חשובים. ב-Deep Learning, הרשת לומדת לבד אילו פיצ'רים רלוונטיים.

תחשבו על זה ככה: אם אתם רוצים לזהות חתול בתמונה, ב-ML הקלאסי הייתם צריכים לתכנת חוקים — "חפש אוזניים משולשות, חפש שפם". ב-Deep Learning, אתם מראים לרשת 10,000 תמונות של חתולים ו-10,000 תמונות בלי חתולים, והיא לומדת לבד מה מגדיר חתול.

רשת נוירונים — מה בפנים?

רשת נוירונים מלאכותית (Artificial Neural Network) בנויה משכבות של "נוירונים" — יחידות חישוב פשוטות שמקבלות קלט, מבצעות חישוב מתמטי (כפל במשקולות, חיבור, והעברה דרך פונקציית הפעלה), ומעבירות את התוצאה הלאה. שכבת הקלט (Input Layer) מקבלת את הנתונים הגולמיים. שכבות הביניים (Hidden Layers) מעבדות את המידע ומחלצות דפוסים ברמות מורכבות יותר ויותר. שכבת הפלט (Output Layer) נותנת את התשובה הסופית.

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

בואו ניגש לעניין. לא צריך מחשב-על כדי להתחיל — צריך מחשב עם חיבור לאינטרנט ורצון לעשות. הנה מה שצריך להכין.

הכנת סביבת העבודה

הדרך המהירה והחינמית ביותר להתחיל עם Deep Learning היא דרך Google Colab — סביבת Jupyter Notebook בענן שמגיעה עם GPU בחינם. לא צריך להתקין כלום על המחשב. פשוט נכנסים ל-colab.research.google.com, פותחים notebook חדש, ומתחילים לכתוב קוד.

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

# יצירת סביבה וירטואלית נקייה
python3 -m venv deeplearning-env
source deeplearning-env/bin/activate  # Linux/Mac
# deeplearning-env\Scripts\activate  # Windows

# התקנת הספריות הבסיסיות
pip install tensorflow numpy matplotlib pandas scikit-learn

# לבדיקה שהכל עובד
python -c "import tensorflow as tf; print(f'TensorFlow version: {tf.__version__}')"

אם יש לכם כרטיס מסך של NVIDIA, תוכלו להריץ אימון על GPU מקומי — וזה מאיץ את הלמידה באופן דרמטי. אבל בהחלט אפשר להתחיל בלי. לרשתות קטנות ודאטה-סטים קלאסיים, CPU מספיק.

בחירת Framework — השוואת כלים

יש כמה Frameworks מרכזיים ללמידה עמוקה. הנה השוואה מעשית שתעזור לבחור:

ההמלצה שלי למי שרק מתחיל: TensorFlow עם Keras. ה-API ברור, התיעוד מעולה, וזה מה שרוב חברות הטכנולוגיה בישראל — מ-Mobileye ועד חברות סטארטאפ קטנות — משתמשות ב-production. כשתרגישו בטוחים, תעברו ל-PyTorch לפרויקטי מחקר.

מספיק תיאוריה. בואו נבנה רשת נוירונים אמיתית שמזהה ספרות בכתב יד. נשתמש בדאטה-סט MNIST — מעין "Hello World" של עולם ה-Deep Learning. זה מאגר של 70,000 תמונות של ספרות בכתב יד (0-9), בגודל 28x28 פיקסלים.

שלב 1: טעינת נתונים והכנתם

import tensorflow as tf
from tensorflow import keras
import numpy as np
import matplotlib.pyplot as plt

# טעינת דאטה-סט MNIST — כבר מובנה ב-Keras
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

# בדיקה מהירה — מה הצורה של הנתונים
print(f"Training data shape: {x_train.shape}")   # (60000, 28, 28)
print(f"Test data shape: {x_test.shape}")         # (10000, 28, 28)
print(f"Pixel value range: {x_train.min()} - {x_train.max()}")  # 0 - 255

# נורמליזציה — להביא את ערכי הפיקסלים לטווח 0-1
# זה חשוב! רשתות נוירונים עובדות הרבה יותר טוב עם ערכים קטנים
x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0

# שיטוח (Flatten) — להפוך כל תמונה 28x28 לוקטור של 784 ערכים
x_train_flat = x_train.reshape(-1, 784)
x_test_flat = x_test.reshape(-1, 784)

# הצגת כמה דוגמאות
fig, axes = plt.subplots(1, 5, figsize=(12, 3))
for i, ax in enumerate(axes):
    ax.imshow(x_train[i], cmap='gray')
    ax.set_title(f"Label: {y_train[i]}")
    ax.axis('off')
plt.tight_layout()
plt.show()

כמה דברים חשובים כאן. הנורמליזציה (חלוקה ב-255) היא לא בחירה אקראית — אלגוריתמי אופטימיזציה כמו Gradient Descent עובדים הרבה יותר יעיל כשהערכים קטנים ובטווח דומה. השיטוח (Flatten) נדרש כי הרשת הפשוטה שנבנה (Dense/Fully Connected) מצפה לוקטור חד-ממדי כקלט, לא מטריצה דו-ממדית.

שלב 2: בניית המודל

# בניית הרשת — Sequential API של Keras
model = keras.Sequential([
    # שכבת קלט — 784 נוירונים (28*28 פיקסלים)
    keras.layers.Dense(128, activation='relu', input_shape=(784,)),
    
    # Dropout — טכניקה למניעת Overfitting
    # "מכבה" 20% מהנוירונים באופן אקראי בזמן אימון
    keras.layers.Dropout(0.2),
    
    # שכבת ביניים נוספת
    keras.layers.Dense(64, activation='relu'),
    
    keras.layers.Dropout(0.2),
    
    # שכבת פלט — 10 נוירונים (ספרה 0-9)
    # softmax הופך את הפלט להתפלגות הסתברות
    keras.layers.Dense(10, activation='softmax')
])

# הידור המודל — הגדרת פונקציית הפסד, אופטימייזר ומדד
model.compile(
    optimizer='adam',               # Adam — אופטימייזר פופולרי ויעיל
    loss='sparse_categorical_crossentropy',  # פונקציית הפסד לסיווג
    metrics=['accuracy']            # מדד דיוק
)

# סיכום הארכיטקטורה
model.summary()

בואו נפרק את מה שקורה כאן. Dense — שכבה מחוברת לחלוטין, כל נוירון מחובר לכל הנוירונים בשכבה הקודמת. ReLU (Rectified Linear Unit) — פונקציית הפעלה פשוטה: אם הערך חיובי — משאירים אותו, אם שלילי — מחזירים 0. זו הפונקציה הנפוצה ביותר בשכבות ביניים. Dropout — טכניקה חכמה שמונעת מהרשת "לשנן" את נתוני האימון (Overfitting) על ידי כיבוי אקראי של נוירונים. Softmax — הופך את הפלט להסתברויות שמסתכמות ל-1. כך הרשת אומרת "יש סיכוי של 95% שזו הספרה 7".

שלב 3: אימון המודל

# אימון הרשת
history = model.fit(
    x_train_flat, y_train,
    epochs=15,                  # 15 מעברים על כל הנתונים
    batch_size=32,              # כל צעד אופטימיזציה — 32 דוגמאות
    validation_split=0.2,       # 20% מנתוני האימון לוולידציה
    verbose=1                   # להציג התקדמות
)

# הערכת ביצועים על נתוני הבדיקה (שהרשת מעולם לא ראתה)
test_loss, test_accuracy = model.evaluate(x_test_flat, y_test, verbose=0)
print(f"\nTest Accuracy: {test_accuracy:.4f}")
print(f"Test Loss: {test_loss:.4f}")

אחרי 15 epochs, אתם אמורים לקבל דיוק של בערך 97-98% על נתוני הבדיקה. לא רע בכלל לרשת פשוטה שלקח 5 דקות לבנות! זכרו — אנחנו מסווגים 10,000 תמונות שהרשת מעולם לא ראתה, ובכל זאת היא מצליחה לזהות נכון כמעט כל ספרה.

שלב 4: ויזואליזציה של תהליך הלמידה

# גרף למידה — איך הדיוק השתפר עם הזמן
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))

# דיוק
ax1.plot(history.history['accuracy'], label='Training Accuracy')
ax1.plot(history.history['val_accuracy'], label='Validation Accuracy')
ax1.set_title('Model Accuracy over Epochs')
ax1.set_xlabel('Epoch')
ax1.set_ylabel('Accuracy')
ax1.legend()
ax1.grid(True)

# הפסד
ax2.plot(history.history['loss'], label='Training Loss')
ax2.plot(history.history['val_loss'], label='Validation Loss')
ax2.set_title('Model Loss over Epochs')
ax2.set_xlabel('Epoch')
ax2.set_ylabel('Loss')
ax2.legend()
ax2.grid(True)

plt.tight_layout()
plt.show()

# ניבוי על דוגמאות ספציפיות
predictions = model.predict(x_test_flat[:5])
for i in range(5):
    predicted_digit = np.argmax(predictions[i])
    confidence = predictions[i][predicted_digit] * 100
    print(f"Image {i}: Predicted={predicted_digit}, "
          f"Actual={y_test[i]}, Confidence={confidence:.1f}%")

הגרף הזה הוא הכלי הכי חשוב שלכם. אם אתם רואים שה-Training Accuracy עולה אבל ה-Validation Accuracy מפסיקה לעלות או יורדת — זה Overfitting. הרשת "משננת" במקום ללמוד. הפתרון: יותר Dropout, יותר נתונים, או רשת פשוטה יותר.

MNIST הוא התרגיל הראשון, לא היעד. בעולם האמיתי, התמונות מורכבות יותר, הנתונים מלוכלכים יותר, והבעיות מעניינות יותר. הנה לאן להתקדם.

רשתות קונבולוציוניות — CNN

לזיהוי תמונות אמיתי, משתמשים ב-Convolutional Neural Networks (CNN) — רשתות שיודעות לחלץ פיצ'רים מרחביים מתמונות. במקום לשטח את התמונה לוקטור אחד ארוך, CNN שומרות על המבנה הדו-ממדי ומחפשות דפוסים מקומיים — קצוות, צורות, מרקמים.

לפי מחקר של Stanford מ-2022, ארכיטקטורות CNN מודרניות מגיעות לדיוק של 99.7% על MNIST ולמעל 96% על ImageNet — שזו משימת סיווג עם 1,000 קטגוריות של אובייקטים מהעולם האמיתי. הנה דוגמה מהירה לבניית CNN ב-Keras:

# CNN למתקדמים — ארכיטקטורה בסיסית
cnn_model = keras.Sequential([
    # שכבת קונבולוציה ראשונה — 32 פילטרים בגודל 3x3
    keras.layers.Conv2D(32, (3, 3), activation='relu', 
                        input_shape=(28, 28, 1)),
    keras.layers.MaxPooling2D((2, 2)),
    
    # שכבת קונבולוציה שנייה — 64 פילטרים
    keras.layers.Conv2D(64, (3, 3), activation='relu'),
    keras.layers.MaxPooling2D((2, 2)),
    
    # שכבת קונבולוציה שלישית
    keras.layers.Conv2D(64, (3, 3), activation='relu'),
    
    # מעבר לשכבות Dense
    keras.layers.Flatten(),
    keras.layers.Dense(64, activation='relu'),
    keras.layers.Dropout(0.5),
    keras.layers.Dense(10, activation='softmax')
])

# הכנת הנתונים — CNN צריך מימד ערוץ (channel)
x_train_cnn = x_train.reshape(-1, 28, 28, 1)
x_test_cnn = x_test.reshape(-1, 28, 28, 1)

cnn_model.compile(optimizer='adam',
                  loss='sparse_categorical_crossentropy',
                  metrics=['accuracy'])

cnn_model.fit(x_train_cnn, y_train, epochs=10, 
              batch_size=64, validation_split=0.2)

# ציפייה: דיוק של 99%+ על MNIST
cnn_test_loss, cnn_test_acc = cnn_model.evaluate(x_test_cnn, y_test)
print(f"CNN Test Accuracy: {cnn_test_acc:.4f}")

שימו לב להבדל: הרשת הפשוטה (Dense) הגיעה ל-97-98%, ה-CNN מגיעה ל-99%+. ועל משימות מורכבות יותר, הפער הרבה יותר גדול.

Transfer Learning — לעמוד על כתפיהם של ענקים

אחד הקונספטים הכי חשובים ב-Deep Learning המודרני הוא Transfer Learning — העברת ידע. במקום לאמן רשת מאפס על מיליוני תמונות, לוקחים רשת שכבר אומנה (כמו ResNet50 או EfficientNet שאומנו על ImageNet), ומתאימים אותה למשימה שלכם עם כמה מאות או אלפי דוגמאות.

זו הסיבה שחברות בישראל כמו OrCam (זיהוי טקסט ואובייקטים לכבדי ראייה) ו-AnyVision (כיום Oosto — זיהוי פנים) יכולות לבנות מוצרים מדהימים בלי לאמן מודלים מאפס. הן לוקחות מודלים קיימים ומתאימות אותם לדומיין הספציפי שלהן.

בפרויקט Edge AI למשל, אפשר לקחת מודל MobileNet שמותאם להרצה על מכשירים עם משאבים מוגבלים, לעשות לו Fine-tuning על הנתונים שלכם, ולהריץ אותו על Raspberry Pi או מכשיר מובייל. זה כבר לא מדע בדיוני — זה יום שלישי בחברת הייטק ישראלית.

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

1. קפיצה ישר לארכיטקטורות מורכבות

כולם רוצים לבנות GPT. אף אחד לא רוצה להבין קודם Logistic Regression. זו טעות. אם אתם לא מבינים איך עובד Gradient Descent על רשת פשוטה, אתם לא תדעו לדבג Transformer עם 100 מיליון פרמטרים. תתחילו קטן. תבינו כל שכבה. רק אז תגדלו.

2. התעלמות מהנתונים

יש אמרה ידועה בתעשייה: "Garbage in, garbage out". לפי מחקר של Google AI מ-2021, שיפור איכות הנתונים משפיע פי 3-10 יותר על הביצועים מאשר שינוי ארכיטקטורת הרשת. לפני שמסבכים את המודל — תנקו את הנתונים, תוודאו שהם מגוונים, ותבדקו שאין הטיה (bias).

3. אימון בלי Validation

אם אתם מודדים ביצועים רק על נתוני האימון — אתם משקרים לעצמכם. תמיד תשמרו חלק מהנתונים ל-validation ו-test. ה-Test Set לא נגעים בו עד הסוף — הוא המבחן האמיתי.

4. לא לנרמל את הנתונים

זוכרים את החלוקה ב-255 שעשינו? בלעדיה, האימון יכול להתכנס לאט מאוד או בכלל לא. כל קלט לרשת צריך להיות בטווח סביר — בדרך כלל 0-1 או -1 עד 1.

האם צריך לדעת מתמטיקה כדי ללמוד Deep Learning?

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

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

כל מחשב עם חיבור לאינטרנט מספיק. Google Colab נותן גישה חינמית ל-GPU בענן. כשתתקדמו ותרצו לאמן מודלים גדולים, תוכלו לשכור GPU בענן (AWS, GCP, או Lambda Labs) או להשקיע בכרטיס מסך NVIDIA RTX 3060 ומעלה למחשב הביתי.

כמה זמן לוקח ללמוד Deep Learning ברמה שמאפשרת עבודה?

עם לימוד ממוקד ופרויקטים מעשיים — 4-6 חודשים של עבודה עקבית (2-3 שעות ביום) מספיקים כדי להגיע לרמה שבה אפשר לתרום לצוות. לא מדובר רק בקורסים — חשוב לבנות 3-4 פרויקטים אמיתיים ולהעלות אותם ל-GitHub. מגייסים בתעשייה הישראלית מחפשים Portfolio, לא רק תעודות.

מה ההבדל בין TensorFlow ל-PyTorch ומה לבחור?

TensorFlow (עם Keras) מצוין למתחילים ול-Production. PyTorch אינטואיטיבי יותר למחקר ולניסויים. בתעשייה הישראלית, שניהם נפוצים מאוד. ההמלצה: תתחילו עם TensorFlow/Keras, ואחרי שתרגישו בטוחים — תלמדו גם PyTorch. לדעת את שניהם זה יתרון ממשי בשוק העבודה.

האם Deep Learning רלוונטי רק לתמונות?

ממש לא. Deep Learning משמש לעיבוד שפה טבעית (NLP — כמו ChatGPT), זיהוי דיבור, מערכות המלצה (Netflix, Spotify), אנליטיקה רפואית, נהיגה אוטונומית, זיהוי חריגות במערכות אבטחה, ניתוח סדרות זמן פיננסיות, ועוד עשרות תחומים. זיהוי תמונות הוא רק הדוגמה הנגישה ביותר ללימוד.

איך ממשיכים אחרי MNIST?

הצעד הבא הטבעי: לעבוד על CIFAR-10 (תמונות צבעוניות — מכוניות, חתולים, מטוסים), לבנות CNN, ואז להתנסות ב-Transfer Learning עם מודלים קיימים על דאטה-סט שמעניין אתכם. בניתם מסווג תמונות? נסו NLP — בנו מודל שמנתח סנטימנט בביקורות. הגיוון הוא מה שבונה הבנה אמיתית.

האם אפשר ללמוד Deep Learning בעברית?

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

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

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