בניית תיק עבודות AI שיפתח דלתות בהייטק

התשובה הקצרה: כדי לבנות תיק עבודות (Portfolio) בתחום ה-AI שבאמת יפתח לכם דלתות בתעשיית ההייטק הישראלית, אתם צריכים שלושה עד חמישה פרויקטים מעשיים שמדגימים יכולת אמיתית — לא תעודות, לא קורסים אונליין שסיימתם, אלא קוד שרץ, תוצאות שאפשר למדוד, ותיעוד שמראה שאתם יודעים לחשוב כמו מהנדסים ולא רק להריץ notebooks. תיק עבודות חזק הוא לא אוסף של תרגילי Kaggle — הוא סיפור שמראה שאתם פותרים בעיות אמיתיות, מבינים את ה-pipeline המלא מ-data ועד deployment, ויודעים לתקשר את מה שעשיתם. לפי סקר של Stack Overflow מ-2024, ל-72% מהמגייסים בתחום ה-AI חשוב יותר תיק עבודות מקצועי מאשר תואר רשמי. בואו נראה בדיוק איך עושים את זה.

בואו נדבר דוגרי: שוק ההייטק הישראלי רעב לאנשי AI. לפי דו"ח רשות החדשנות לשנת 2024, כ-47% מחברות ההייטק בישראל מדווחות על מחסור באנשי Machine Learning ו-Deep Learning. אבל "רעב" לא אומר "מקבלים כל אחד" — הפוך. כשיש ביקוש ענק, גם התחרות עולה, וכולם מחפשים את הדרך להתבלט.

קורות חיים עם רשימת קורסים ב-Coursera ו-Udemy? כולם כבר יודעים שזה לא מספיק. תואר אקדמי? הוא פותח דלתות, בלי ספק, אבל הוא לא מבדיל אתכם מעשרות מועמדים אחרים עם אותו תואר. מה כן מבדיל? עבודה שאפשר לראות, לגעת, להריץ.

מה מגייסים באמת מחפשים כשהם נכנסים ל-GitHub שלכם

שוחחתי עם עשרות מנהלי גיוס ו-team leads בחברות ישראליות — מסטארטאפים בתחילת דרכם ועד חברות מבוססות כמו Mobileye, Hailo ו-Run:ai. הדבר הראשון שהם מחפשים הוא לא קוד מושלם. הם מחפשים חשיבה. הם רוצים לראות שהבנתם את הבעיה, בחרתם גישה, ניסיתם, נכשלתם, שיפרתם, ותיעדתם. README מסודר עם הסבר למה בחרתם ארכיטקטורה מסוימת שווה יותר ממודל עם accuracy של 99% בלי הקשר.

הנקודה הקריטית: מגייסים מקדישים בממוצע 6-8 דקות לצפייה בתיק עבודות. אם בזמן הזה הם לא מבינים מה עשיתם ולמה — עברתם לערימת ה"אולי". ו"אולי" בעולם הגיוס אומר "לא".

ההבדל בין תיק עבודות חובבני למקצועי

תיק עבודות חובבני נראה ככה: notebook ב-Google Colab עם קוד שמריץ מודל על dataset מוכן, בלי תיעוד, בלי הסבר, בלי deployment. תיק עבודות מקצועי נראה ככה: פרויקט ב-GitHub עם README מפורט, קוד מסודר במודולים, Dockerfile שמאפשר להריץ את הכל, תוצאות מתועדות, ו-blog post קצר שמסביר את התהליך.

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

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

פרויקט 1: Computer Vision עם deployment אמיתי

תחום ה-Computer Vision הוא אחד מהתחומים הכי חמים בהייטק הישראלי — חשבו על Mobileye, OrCam, AnyVision (הוק AI). פרויקט שבו אתם מאמנים מודל לזיהוי אובייקטים (Object Detection) ומבצעים לו deployment לסביבה אמיתית — גם אם זה Raspberry Pi או שרת Flask פשוט — מראה שאתם מבינים את כל השרשרת.

דוגמה טובה: אימון מודל YOLOv8 לזיהוי תקלות ב-PCB (לוחות מעגלים מודפסים), deployment ל-Edge device, ומדידת ביצועים (inference time, accuracy, resource usage). זה אומר משהו לכל מגייס שקורא את זה.

פרויקט 2: NLP עם ערך עסקי ברור

Natural Language Processing הוא תחום שצמח בצורה מטורפת עם מודלים כמו GPT, BERT, ו-LLaMA. פרויקט NLP מעניין הוא לא "ניתוח סנטימנט על ביקורות סרטים" — זה כבר נעשה מיליון פעם. פרויקט מעניין הוא כזה שפותר בעיה שאנשים אכפת להם ממנה.

דוגמה טובה: RAG (Retrieval-Augmented Generation) pipeline שמחבר מודל שפה לבסיס ידע ספציפי — למשל, מערכת שעונה על שאלות טכניות מתוך תיעוד פנימי. זה מראה שאתם מבינים את ארכיטקטורת ה-LLM המודרנית, לא רק קוראים ל-API.

פרויקט 3: Data Engineering — הצד שכולם מדלגים עליו

לפי מחקר של Anaconda מ-2023, מדעני נתונים מבלים כ-45% מהזמן שלהם בניקוי והכנת דאטה. תיק עבודות שלא מראה שאתם יודעים לעבוד עם דאטה "מלוכלך" — הוא תיק עבודות חלקי. פרויקט שכולל data pipeline מלא — מ-ingestion דרך cleaning ו-transformation ועד feature engineering — מראה בגרות מקצועית.

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

פרויקט 4: Edge AI / Embedded ML

הנה הדבר שרוב האנשים לא יגידו לכם: Edge AI הוא אחד התחומים עם הביקוש הגבוה ביותר בישראל. חברות כמו Hailo, Brodmann17, ו-Sensing.ai מחפשות אנשים שמבינים איך להריץ מודלים במגבלות חומרה אמיתיות. אם אתם יודעים לעשות quantization, pruning, ולהריץ מודל TensorFlow Lite על מיקרו-בקר — יש לכם יתרון ענק.

דוגמה טובה: המרת מודל סיווג לפורמט TFLite, הרצה על Raspberry Pi או ESP32, מדידת latency ושימוש בזיכרון, ותיעוד של ה-tradeoffs שביצעתם.

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

צעד 1: בחירת datasets והגדרת בעיה

אל תתחילו מהמודל — תתחילו מהבעיה. שאלו את עצמכם: "מה הבעיה שהפרויקט הזה פותר?" אם אין לכם תשובה ברורה — עדיין לא הגדרתם בעיה. Kaggle הוא מקום טוב למצוא datasets, אבל שקלו גם מקורות כמו Papers With Code, Hugging Face Datasets, ו-UCI Machine Learning Repository.

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

צעד 2: מבנה פרויקט מקצועי ב-Git

מבנה הפרויקט ב-GitHub שלכם הוא הדבר הראשון שמגייסים רואים. הנה מבנה שעובד:

# יצירת מבנה פרויקט מקצועי
mkdir my-ai-project && cd my-ai-project
git init

# יצירת מבנה תיקיות תקני
mkdir -p src/{data,models,utils,api}
mkdir -p notebooks
mkdir -p tests
mkdir -p configs
mkdir -p docs
mkdir -p docker

# קבצי בסיס
touch README.md
touch requirements.txt
touch Dockerfile
touch .gitignore
touch src/__init__.py
touch src/data/preprocess.py
touch src/models/train.py
touch src/models/evaluate.py
touch src/api/serve.py
touch configs/config.yaml
touch tests/test_model.py

# .gitignore בסיסי לפרויקט AI
cat > .gitignore << 'EOF'
__pycache__/
*.pyc
.env
data/raw/
*.h5
*.pt
*.onnx
wandb/
.ipynb_checkpoints/
EOF

echo "מבנה פרויקט נוצר בהצלחה"
tree -L 3

שימו לב: מודלים מאומנים וקבצי דאטה גדולים לא נכנסים ל-Git — השתמשו ב-Git LFS או ב-DVC (Data Version Control) כדי לנהל אותם. זה בדיוק סוג הפרט שמראה למגייסים שאתם מבינים תהליכי עבודה אמיתיים.

צעד 3: README שמספר סיפור

ה-README הוא הדבר הכי חשוב ב-repository שלכם. הוא הדלת הכניסה לפרויקט. הנה מבנה README שעובד:

# דוגמה למבנה README.md מקצועי
cat > README.md << 'EOF'
# PCB Defect Detection with YOLOv8

## 🎯 Problem Statement
Automated detection of manufacturing defects on PCBs,
reducing manual QA inspection time by ~60%.

## 🏗️ Architecture
- **Model**: YOLOv8-nano (optimized for edge deployment)
- **Training**: PyTorch + Ultralytics on NVIDIA RTX 3080
- **Inference**: ONNX Runtime on Raspberry Pi 4
- **Monitoring**: Weights & Biases (W&B)

## 📊 Results
| Metric | Value |
|--------|-------|
| mAP@50 | 0.89  |
| Inference (GPU) | 12ms |
| Inference (RPi4) | 180ms |
| Model Size (INT8) | 6.2MB |

## 🚀 Quick Start
```bash
git clone https://github.com/yourname/pcb-defect-detection
cd pcb-defect-detection
pip install -r requirements.txt
python src/models/train.py --config configs/config.yaml
```

## 📁 Project Structure
[tree structure here]

## 🤔 Design Decisions
- Chose YOLOv8-nano over YOLOv8-large for edge deployment constraints
- Applied INT8 quantization with <2% accuracy drop
- Used albumentation for augmentation (rotation, blur, color jitter)

## 📝 Blog Post
[Link to detailed write-up]
EOF

שימו לב לסעיף "Design Decisions" — זה הסעיף שמפריד בין מי שהעתיק tutorial לבין מי שחושב כמו מהנדסי AI. הסבירו למה בחרתם את מה שבחרתם, מה הייתם עושים אחרת, ומה ה-tradeoffs.

צעד 4: קוד אימון מתועד ומסודר

הנה דוגמה לסקריפט אימון שמדגים תהליך עבודה מקצועי — לא notebook מבולגן אלא קוד production-ready:

"""
train.py - PCB Defect Detection Training Pipeline
Author: Your Name
Date: 2024-12-01
"""

import yaml
import torch
import wandb
from pathlib import Path
from ultralytics import YOLO
from datetime import datetime


def load_config(config_path: str = "configs/config.yaml") -> dict:
    """טוען קובץ קונפיגורציה."""
    with open(config_path, "r") as f:
        return yaml.safe_load(f)


def setup_wandb(config: dict, project_name: str = "pcb-defect-detection"):
    """מאתחל Weights & Biases למעקב אחרי ניסויים."""
    wandb.init(
        project=project_name,
        config=config,
        name=f"run_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
    )


def train_model(config: dict) -> None:
    """תהליך אימון ראשי."""
    
    # טעינת מודל בסיס
    model = YOLO(config["model"]["base_weights"])  # e.g., "yolov8n.pt"
    
    # אימון
    results = model.train(
        data=config["data"]["yaml_path"],
        epochs=config["training"]["epochs"],
        imgsz=config["training"]["img_size"],
        batch=config["training"]["batch_size"],
        lr0=config["training"]["learning_rate"],
        device=config["training"]["device"],
        patience=config["training"]["early_stopping_patience"],
        save=True,
        project="runs/train",
        name=config["experiment"]["name"]
    )
    
    # הערכה על test set
    metrics = model.val(data=config["data"]["yaml_path"])
    
    print(f"mAP@50: {metrics.box.map50:.4f}")
    print(f"mAP@50-95: {metrics.box.map:.4f}")
    
    # ייצוא לפורמטים שונים
    model.export(format="onnx", imgsz=config["training"]["img_size"])
    print("Model exported to ONNX format")
    
    # לוג תוצאות ל-W&B
    wandb.log({
        "mAP50": metrics.box.map50,
        "mAP50_95": metrics.box.map,
        "precision": metrics.box.mp,
        "recall": metrics.box.mr
    })
    
    wandb.finish()


if __name__ == "__main__":
    config = load_config()
    setup_wandb(config)
    train_model(config)

שימו לב: type hints, docstrings, קונפיגורציה חיצונית ב-YAML, לוגים ל-Weights & Biases, וייצוא לפורמט ONNX. זה לא "קוד שרץ" — זה קוד שמדבר. מגייסים קוראים את הקוד הזה ומבינים שאתם עובדים כמו שצוותי AI באמת עובדים.

יש הרבה כלים בשוק, ואחד האתגרים הוא לבחור את הנכונים. הנה טבלת השוואה שתעזור לכם להחליט:

ההמלצה שלי: אל תבחרו אחד — שלבו. כל פרויקט צריך repository ב-GitHub (בסיס), אבל לפחות שניים מתוך שלושה עד חמישה פרויקטים צריכים גם demo חי ב-Hugging Face Spaces או Streamlit, ו-blog post ב-GitHub Pages או Medium שמסביר את התהליך.

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

נוסחת ה-STAR למהנדסי AI

השתמשו בנוסחת STAR מותאמת לעולם הטכני:

Situation (מצב): מה הבעיה שזיהיתם? למשל: "בדיקת איכות ידנית של PCBs גוזלת 4 שעות ביום וחוטאת ב-12% מהמקרים."

Task (משימה): מה הגדרתם כיעד? למשל: "בניית מערכת זיהוי אוטומטית עם דיוק מעל 85% ו-inference time מתחת ל-200ms."

Action (פעולה): מה עשיתם בפועל? כאן נכנסים הפרטים הטכניים: ארכיטקטורה, data pipeline, ניסויים שנכשלו ולקחים.

Result (תוצאה): מספרים. תמיד מספרים. "mAP של 0.89, הפחתה של 60% בזמן הבדיקה, מודל של 6.2MB שרץ על Raspberry Pi." מספרים הם השפה שמגייסים מדברים.

הטעויות הנפוצות שהורסות תיקי עבודות

הנה רשימת הטעויות הכי נפוצות שאני רואה שוב ושוב, ואיך לתקן אותן:

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

טעות 2: רק Jupyter Notebooks. Notebooks מצוינים לחקירה ראשונית, אבל תיק עבודות צריך להראות קוד מודולרי בקבצי .py. זה מראה שאתם יודעים לכתוב קוד production ולא רק קוד אקספלורטורי.

טעות 3: אין deployment. מודל שחי רק ב-notebook הוא מודל שלא באמת עובד. גם API פשוט ב-FastAPI או demo ב-Streamlit מספיקים כדי להראות שאתם מבינים את המושג.

טעות 4: אין מספרים. "המודל עובד טוב" הוא לא תוצאה. "precision של 0.92, recall של 0.87, inference time של 45ms על RTX 3080" — זו תוצאה.

טעות 5: פרויקטים זהים. חמישה פרויקטים של סיווג תמונות עם CNN מדגימים שאתם יודעים לעשות דבר אחד. עדיף שלושה פרויקטים מגוונים על חמישה כפולים.

מעבר למודלים עצמם, מגייסים רוצים לראות שאתם שולטים ב-toolchain המודרני של AI/ML. הנה הכלים שצריכים להופיע בפרויקטים שלכם:

ניהול ניסויים וגרסאות מודלים

השתמשו ב-MLflow, Weights & Biases, או DVC כדי לתעד ניסויים. מגייסים רוצים לראות שאתם מבינים את הקונספט של experiment tracking — לא רק "שיחקתי עם hyperparameters עד שעבד".

# דוגמה לשימוש ב-MLflow לניהול ניסויים
import mlflow
import mlflow.pytorch

def run_experiment(model, train_loader, val_loader, config):
    """מריץ ניסוי אימון עם MLflow tracking."""
    
    mlflow.set_experiment("pcb-defect-detection")
    
    with mlflow.start_run(run_name=config["run_name"]):
        # לוג hyperparameters
        mlflow.log_params({
            "learning_rate": config["lr"],
            "batch_size": config["batch_size"],
            "epochs": config["epochs"],
            "model_arch": config["architecture"],
            "optimizer": config["optimizer"],
            "img_size": config["img_size"]
        })
        
        # אימון
        for epoch in range(config["epochs"]):
            train_loss = train_one_epoch(model, train_loader)
            val_loss, val_metrics = evaluate(model, val_loader)
            
            # לוג מטריקות לכל epoch
            mlflow.log_metrics({
                "train_loss": train_loss,
                "val_loss": val_loss,
                "val_mAP50": val_metrics["mAP50"],
                "val_precision": val_metrics["precision"],
                "val_recall": val_metrics["recall"]
            }, step=epoch)
        
        # שמירת מודל כ-artifact
        mlflow.pytorch.log_model(model, "model")
        
        # לוג artifacts נוספים
        mlflow.log_artifact("configs/config.yaml")
        mlflow.log_artifact("results/confusion_matrix.png")
        
        print(f"Run ID: {mlflow.active_run().info.run_id}")

הקוד הזה מראה שאתם לא רק מאמנים מודל — אתם מנהלים תהליך מחקר שיטתי. זה ההבדל בין ג'וניור ל-mid-level.

Containerization ו-Deployment

ידע ב-Docker הוא כמעט חובה היום. הנה Dockerfile שמראה שאתם יודעים לארוז מודל AI כ-microservice:

# Dockerfile לשירות inference של מודל AI
FROM python:3.11-slim

WORKDIR /app

# התקנת dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# העתקת קוד ומודל
COPY src/ ./src/
COPY models/best_model.onnx ./models/

# חשיפת פורט
EXPOSE 8000

# Health check
HEALTHCHECK --interval=30s --timeout=10s \
  CMD curl -f http://localhost:8000/health || exit 1

# הרצת שרת
CMD ["uvicorn", "src.api.serve:app", "--host", "0.0.0.0", "--port", "8000"]

# בנייה והרצה
docker build -t pcb-defect-api:v1 .
docker run -p 8000:8000 pcb-defect-api:v1

# בדיקה שהשירות עובד
curl http://localhost:8000/health
curl -X POST http://localhost:8000/predict \
  -F "image=@test_images/sample_pcb.jpg"

כשמגייס רואה Dockerfile ב-repository שלכם — הוא מבין שאתם חושבים על deployment ולא רק על אימון. זה מבדיל אתכם מ-90% מהמועמדים.

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

חודש 1 — יסודות ופרויקט ראשון: הקמת GitHub profile מסודר, למידת Git workflow מקצועי, השלמת פרויקט CV פשוט עם README מלא ו-deployment בסיסי.

חודש 2 — הרחבה: פרויקט NLP או Data Engineering, שילוב experiment tracking, כתיבת blog post ראשון על הפרויקט הראשון.

חודש 3 — ליטוש ו-Edge: פרויקט Edge AI או פרויקט end-to-end מורכב, עדכון README לכל הפרויקטים, בניית landing page אישי ב-GitHub Pages.

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

כמה פרויקטים צריכים להיות בתיק עבודות AI?

שלושה עד חמישה פרויקטים איכותיים. עדיף שלושה פרויקטים מעולים עם README מפורט, קוד מסודר, ו-demo חי — מאשר עשרה repositories חצי-מוכנים. מגייסים מעריכים עומק ואיכות, לא כמות. ודאו שכל פרויקט מדגים יכולת שונה: אחד CV, אחד NLP, אחד data pipeline — ככה אתם מראים רוחב.

האם צריך תואר אקדמי כדי להתקבל לעבודה בתחום ה-AI בישראל?

תואר עוזר, בלי ספק, אבל הוא לא תנאי הכרחי. לפי סקר של Israel Tech Jobs מ-2024, כ-35% מהמשרות בתחום ה-ML בישראל לא דורשות תואר ספציפי — הן דורשות ניסיון מוכח ויכולת. תיק עבודות חזק יכול לפצות על היעדר תואר, במיוחד בסטארטאפים שמחפשים builders, לא תעודות. אבל בואו נהיה כנים: לחברות מחקר כמו Google Research או Meta AI — תואר שני או שלישי הוא כמעט חובה.

האם פרויקטי Kaggle נחשבים לתיק עבודות?

תחרויות Kaggle הן נקודת התחלה טובה, אבל הן לא מספיקות לבד. הסיבה: הן מדגימות בעיקר model building על דאטה נקי ומוכן. מגייסים רוצים לראות גם data engineering, deployment, ותיעוד. הדרך הנכונה: קחו תחרות Kaggle שהשתתפתם בה, הרחיבו אותה — הוסיפו deployment, כתבו blog post שמסביר את הגישה שלכם, ותעלו את הכל ל-GitHub מסודר.

באילו שפות תכנות כדאי להציג את הפרויקטים?

Python היא חובה — היא שפת הסטנדרט של עולם ה-AI/ML. אם יש לכם פרויקט Edge AI — הוסיפו C/C++ כדי להראות שאתם מתמודדים עם אילוצי חומרה. SQL לפרויקטי data pipeline. ו-Bash scripting לתשתיות וב-automation. מה שחשוב: אל תכתבו ב-Java או C# רק כי אתם יודעים — זה לא רלוונטי לתחום ופרויקטים בשפות לא מתאימות עלולים לבלבל את התמונה.

איך מתמודדים עם חוסר ניסיון מעשי כשמתחילים מאפס?

כולם מתחילים מאפס — גם אנשים שהיום מובילים צוותי AI. הסוד הוא להתחיל מפרויקטים שמבוססים על בעיות אמיתיות, גם אם הפתרון פשוט. שכפלו מאמר מחקר ידוע (paper reproduction), קחו dataset ציבורי ופתרו בעיה שמעניינת אתכם, או השתתפו בפרויקט קוד פתוח. הדבר החשוב הוא להתחיל ולשפר תוך כדי תנועה. אף אחד לא מצפה מג'וניורים לשלמות — הם מצפים לראות למידה מתמדת ורצון אמיתי.

האם כדאי לבנות אתר Portfolio אישי מעבר ל-GitHub?

כן, מומלץ מאוד. GitHub הוא הבסיס, אבל אתר אישי ב-GitHub Pages או דומיין פרטי מוסיף רמה של מקצועיות. באתר אתם יכולים להציג את הפרויקטים עם screenshots ו-GIFs, להוסיף blog posts שמסבירים את התהליך, ולספר את הסיפור שלכם בצורה אנושית. לפי נתוני LinkedIn, פרופילים עם קישור לאתר Portfolio אישי מקבלים פי 2.3 יותר פניות ממגייסים בתחום הטכנולוגי.

כמה זמן לוקח לבנות תיק עבודות שיספיק כדי להתחיל לחפש עבודה?

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

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

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