פרויקטים מעשיים שכל AI Engineer חייב בתיק העבודות

לא צריך תואר, צריך רעב ואת המעבדה הנכונה, זו לא סיסמה, זו המציאות של שוק העבודה בתחום הבינה המלאכותית כיום. מנהלי גיוס בחברות כמו Mobileye, Hailo ו-Run:ai אומרים את זה שוב ושוב: "תראו לי מה בניתם." לא איפה למדתם. לא כמה קורסים סיימתם ב-Coursera. מה בניתם. תיק עבודות הוא כרטיס הכניסה. במדריך הזה נלך צעד אחרי צעד דרך חמישה פרויקטים קונקרטיים שכל AI Engineer צריך לבנות. לכל פרויקט, הסבר למה הוא חשוב, איזה כלים להשתמש בהם, קוד אמיתי שאפשר להריץ, וטיפים ממי שראה מאות תיקי עבודות בחיים. אנחנו רואים אתכם רחוק יותר מאיפה שאתם רואים את עצמכם. עכשיו בואו נבנה את ההוכחה.

סקרים בתעשייה בשנים האחרונות מצביעים על מגמה ברורה: למעלה מ-65% מהמגייסים בתחום ה-AI בישראל אומרים שתיק עבודות עם פרויקטים אמיתיים משפיע על ההחלטה שלהם יותר מכל תעודה. לפי מחקר של Stack Overflow מהשנים האחרונות, מפתחים שהעלו פרויקטים ל-GitHub קיבלו כמעט פי שניים יותר פניות ממגייסים לעומת כאלה שלא.

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

מה מגייסים בישראל באמת מחפשים בתיק עבודות?

אחרי שיחות עם עשרות Team Leads ב-R&D ישראלי, המכנה המשותף ברור: הם רוצים לראות שאתם יודעים לחשוב, לא רק לקפוצ׳ינו קוד מ-Stack Overflow. הם רוצים לראות README מסודר שמסביר למה בחרתם ב-PyTorch ולא ב-TensorFlow, למה בחרתם learning rate מסוים, ואיך מדדתם הצלחה.

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

נקודת מפתח: פרויקט אחד מקצה לקצה שעובד בפרודקשן שווה יותר מעשרה notebooks של Jupyter שנעצרים ב-model.fit().

פרויקט 1: סיווג תמונות עם Deep Learning — האם תוכלו לבנות מסווג שעובד?

זה פרויקט הבסיס, כל AI Engineer חייב להראות שהוא מבין את הליבה של למידה עמוקה: רשתות CNN (Convolutional Neural Networks), שהן רשתות נוירונים שמתמחות בזיהוי תבניות חזותיות בתמונות. הפרויקט צריך להראות יכולת לבנות, לאמן ולהעריך מודל סיווג תמונות.

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

כלים מרכזיים: PyTorch או TensorFlow, Transfer Learning עם מודל ResNet50 מאומן מראש, ו-Augmentation עם Albumentations.

import torch
import torch.nn as nn
import torchvision.models as models
import torchvision.transforms as transforms
from torch.utils.data import DataLoader, WeightedRandomSampler
from torchvision.datasets import ImageFolder
import numpy as np

# Data augmentation pipeline - קריטי לדאטה רפואי קטן
train_transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.RandomHorizontalFlip(p=0.5),
    transforms.RandomRotation(degrees=15),
    transforms.ColorJitter(brightness=0.2, contrast=0.2),
    transforms.RandomAffine(degrees=0, translate=(0.1, 0.1)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                         std=[0.229, 0.224, 0.225])
])

# Load dataset
train_dataset = ImageFolder(root='data/train', transform=train_transform)

# Handle class imbalance with weighted sampler
class_counts = np.bincount([label for _, label in train_dataset])
class_weights = 1.0 / class_counts
sample_weights = [class_weights[label] for _, label in train_dataset]
sampler = WeightedRandomSampler(sample_weights, len(sample_weights))

train_loader = DataLoader(train_dataset, batch_size=32, sampler=sampler)

# Transfer Learning with ResNet50
model = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V2)
num_features = model.fc.in_features
model.fc = nn.Sequential(
    nn.Dropout(0.3),
    nn.Linear(num_features, 256),
    nn.ReLU(),
    nn.Dropout(0.2),
    nn.Linear(256, 2)  # Binary: normal vs suspicious
)

# Loss function with label smoothing for medical data
criterion = nn.CrossEntropyLoss(label_smoothing=0.1)
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4, weight_decay=1e-2)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=30)

# Training loop
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)

for epoch in range(30):
    model.train()
    running_loss = 0.0
    correct = 0
    total = 0

    for images, labels in train_loader:
        images, labels = images.to(device), labels.to(device)
        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        _, predicted = torch.max(outputs, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    scheduler.step()
    accuracy = 100 * correct / total
    print(f'Epoch {epoch+1}/30 - Loss: {running_loss/len(train_loader):.4f} - Acc: {accuracy:.2f}%')

מה לכלול ב-README: מטריקות של Precision, Recall ו-F1-Score (לא רק Accuracy — במחלות רפואיות, Recall חשוב יותר), Confusion Matrix, והסבר מילולי על הבחירות הטכנולוגיות.

פרויקט 2: צ׳אטבוט מבוסס NLP — איך בונים מערכת שמבינה שפה טבעית?

NLP — עיבוד שפה טבעית (Natural Language Processing) — הוא הענף בבינה מלאכותית שעוסק בהבנה וייצור של טקסט אנושי. בעידן של GPT ו-LLM (מודלי שפה גדולים), זה הנושא החם ביותר בשוק. אבל לא מספיק לקרוא ל-API של OpenAI ולהגיד "בניתי צ׳אטבוט." צריך להראות שמבינים את השכבות מתחת.

מה לבנות: צ׳אטבוט תמיכה טכנית שעונה על שאלות על מוצר מסוים. הטריק: לבנות מערכת RAG (Retrieval Augmented Generation) שמושכת מידע ממסמכים פנימיים ומשלבת אותו עם מודל שפה. RAG זו ארכיטקטורה שבה המודל לא מסתמך רק על מה שלמד באימון, אלא "שולף" מידע רלוונטי ממאגר מסמכים לפני שמנסח תשובה.

from langchain.document_loaders import DirectoryLoader, TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.vectorstores import Chroma
from langchain.llms import Ollama
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate

# Step 1: Load and chunk documents
loader = DirectoryLoader('./docs/', glob="**/*.md", loader_cls=TextLoader)
documents = loader.load()

splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50,
    separators=["\n\n", "\n", ". ", " "]
)
chunks = splitter.split_documents(documents)
print(f"Created {len(chunks)} document chunks")

# Step 2: Create embeddings and vector store
embeddings = HuggingFaceEmbeddings(
    model_name="intfloat/multilingual-e5-large",  # supports Hebrew
    model_kwargs={'device': 'cuda'}
)

vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory="./chroma_db"
)

# Step 3: Set up local LLM (privacy-friendly, no API costs)
llm = Ollama(model="llama3.1:8b", temperature=0.3)

# Step 4: Build RAG chain with custom prompt
prompt_template = """Use the following context to answer the question.
If you cannot find the answer in the context, say "I don't have enough information."

Context: {context}

Question: {question}

Answer in a helpful, concise manner:"""

PROMPT = PromptTemplate(
    template=prompt_template,
    input_variables=["context", "question"]
)

qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(search_kwargs={"k": 4}),
    chain_type_kwargs={"prompt": PROMPT},
    return_source_documents=True
)

# Step 5: Query
result = qa_chain({"query": "How do I configure the network settings?"})
print(f"Answer: {result['result']}")
print(f"Sources: {[doc.metadata['source'] for doc in result['source_documents']]}")

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

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

מערכות המלצות (Recommendation Systems) הן הלב של מוצרים כמו Netflix, Spotify ואמזון. כל AI Engineer שווה את המשכורת שלו צריך לדעת לבנות אחת. זו בעיה קלאסית שמשלבת הבנה של נתונים, אלגוריתמיקה, וחשיבה מוצרית.

מה לבנות: מערכת המלצות היברידית שמשלבת שתי גישות — Collaborative Filtering (סינון שיתופי, שמתבסס על דפוסי משתמשים דומים) ו-Content-Based Filtering (סינון מבוסס תוכן, שמתבסס על תכונות הפריטים עצמם). השתמשו ב-dataset אמיתי כמו MovieLens.

כלים: Python, scikit-learn, Surprise Library או PyTorch. הנקודה המרכזית היא לבנות את ההשוואה בין הגישות ולהראות מטריקות ביצועים כמו RMSE (Root Mean Squared Error — כמה גדולה הטעות הממוצעת בחיזוי הדירוג) ו-NDCG (Normalized Discounted Cumulative Gain — כמה טובה הדירוג של ההמלצות).

מה לכלול ב-README: גרפים שמשווים ביצועים בין הגישות, ניתוח של Cold Start Problem (הבעיה שמערכות המלצות לא יודעות מה להמליץ למשתמש חדש), והצעת פתרון.

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

פרויקט 4: הרצת מודל AI על חומרה מוגבלת, מהו Edge AI ולמה הוא קריטי?

Edge AI זה הרצה של מודלים של בינה מלאכותית ישירות על מכשיר קצה, לא בענן. זה אומר טלפון חכם, מצלמה תעשייתית, חיישן, או לוח כמו Raspberry Pi ו-NVIDIA Jetson. בישראל, עם חברות כמו Hailo, Brodmann17 ו-Mobileye, הביקוש למהנדסים שיודעים לדחוס מודלים לרוץ על חומרה מוגבלת הוא עצום.

מה לבנות: מערכת זיהוי אובייקטים בזמן אמת על Raspberry Pi 5 או NVIDIA Jetson Nano. הפרויקט מתחיל מאימון מודל YOLOv8 (מודל מוביל לזיהוי אובייקטים בזמן אמת), המשך בביצוע Quantization (כיווץ המודל מדיוק 32-bit ל-8-bit כדי שירוץ מהר יותר ויתפוס פחות זיכרון), ולבסוף הרצה על החומרה עם מדידת ביצועים.

# Setup on Raspberry Pi 5 / Jetson Nano
pip install ultralytics onnxruntime

# Step 1: Train YOLOv8 on custom dataset (run on GPU machine)
yolo detect train data=custom_dataset.yaml model=yolov8n.pt epochs=100 imgsz=640

# Step 2: Export to ONNX for edge deployment
yolo export model=runs/detect/train/weights/best.pt format=onnx imgsz=416 simplify=True

# Step 3: Quantize model to INT8
python3 -c "
import onnx
from onnxruntime.quantization import quantize_dynamic, QuantType

model_path = 'best.onnx'
quantized_path = 'best_int8.onnx'
quantize_dynamic(model_path, quantized_path, weight_type=QuantType.QUInt8)
print('Quantized model saved!')
"

# Step 4: Run inference on edge device
python3 -c "
import onnxruntime as ort
import cv2
import numpy as np
import time

session = ort.InferenceSession('best_int8.onnx')

cap = cv2.VideoCapture(0)
fps_list = []

while True:
    ret, frame = cap.read()
    if not ret:
        break

    start = time.time()

    # Preprocess
    img = cv2.resize(frame, (416, 416))
    img = img.astype(np.float32) / 255.0
    img = np.transpose(img, (2, 0, 1))[np.newaxis, ...]

    # Inference
    outputs = session.run(None, {session.get_inputs()[0].name: img})

    elapsed = time.time() - start
    fps = 1.0 / elapsed
    fps_list.append(fps)

    print(f'FPS: {fps:.1f} | Avg: {np.mean(fps_list[-100:]):.1f}')

cap.release()
"

# Step 5: Benchmark results
echo "Compare: FP32 model vs INT8 model"
echo "Metric       | FP32    | INT8"
echo "Model size   | 12.3 MB | 3.4 MB"
echo "Avg FPS (Pi5)| 4.2     | 14.8"
echo "[email protected]      | 0.89    | 0.86"

למה זה מבדיל: רוב ה-AI Engineers היום יודעים לאמן מודל בענן. מעטים יודעים לגרום לו לרוץ על חומרה אמיתית עם אילוצי זיכרון וצריכת חשמל. בשוק הישראלי, עם הדגש על ביטחון, רכב אוטונומי ו-IoT תעשייתי, זה הפרויקט שגורם ל-CV שלכם לעלות לראש הערימה.

פרויקט 5: MLOps Pipeline מקצה לקצה, איך מביאים מודל לפרודקשן?

הפער הגדול ביותר בין Junior לבין Senior AI Engineer הוא לא ידע תיאורטי. זו היכולת להביא מודל ל-production. לפי סקרים בתעשייה, כ-87% מפרויקטי ה-ML לא מגיעים אף פעם לפרודקשן. הפרויקט הזה מראה שאתם מבינים את הצד השני — ושם הכסף.

מה לבנות: Pipeline אוטומטי שכולל אימון מודל, ניהול ניסויים עם MLflow (כלי לתיעוד ומעקב אחרי ניסויי ML), פריסה אוטומטית עם Docker ו-FastAPI, וניטור ביצועים לאחר הפריסה.

# FastAPI serving endpoint with MLflow model loading
from fastapi import FastAPI, File, UploadFile
from fastapi.responses import JSONResponse
import mlflow.pyfunc
import numpy as np
from PIL import Image
import io
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

app = FastAPI(title="ML Model Serving API", version="1.0")

# Load model from MLflow registry
MODEL_URI = "models:/skin-classifier/Production"
model = mlflow.pyfunc.load_model(MODEL_URI)
logger.info(f"Model loaded from {MODEL_URI}")

@app.post("/predict")
async def predict(file: UploadFile = File(...)):
    try:
        contents = await file.read()
        image = Image.open(io.BytesIO(contents)).resize((224, 224))
        img_array = np.array(image, dtype=np.float32) / 255.0
        img_array = np.expand_dims(img_array, axis=0)

        prediction = model.predict(img_array)

        return JSONResponse({
            "status": "success",
            "prediction": prediction.tolist(),
            "model_version": MODEL_URI
        })

    except Exception as e:
        logger.error(f"Prediction failed: {e}")
        return JSONResponse({"status": "error", "detail": str(e)}, status_code=500)

@app.get("/health")
async def health():
    return {"status": "healthy", "model": MODEL_URI}

# docker-compose.yml for full MLOps stack
version: '3.8'

services:
  model-api:
    build: ./api
    ports:
      - "8000:8000"
    environment:
      - MLFLOW_TRACKING_URI=http://mlflow:5000
    depends_on:
      - mlflow
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  mlflow:
    image: ghcr.io/mlflow/mlflow:latest
    ports:
      - "5000:5000"
    command: mlflow server --host 0.0.0.0 --port 5000 --backend-store-uri sqlite:///mlflow.db
    volumes:
      - mlflow_data:/mlflow

  prometheus:
    image: prom/prometheus:latest
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml

  grafana:
    image: grafana/grafana:latest
    ports:
      - "3000:3000"
    depends_on:
      - prometheus

volumes:
  mlflow_data:

מה לכלול ב-README: תרשים ארכיטקטורה של ה-pipeline, הוראות הרצה מלאות, ודשבורד Grafana שמציג מטריקות כמו latency, throughput ו-model drift.

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

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

מה חייב להופיע ב-README?

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

1. כותרת ותיאור בשורה אחת — מה הפרויקט עושה, למי הוא מיועד.

2. Demo / תוצאות — GIF, צילום מסך, או קישור ל-live demo. מגייסים נותנים לפרויקט בממוצע 30 שניות. אם אין תמונה, הם ממשיכים הלאה.

3. ארכיטקטורה — תרשים פשוט (אפשר להשתמש ב-Mermaid ב-GitHub) שמראה את ה-flow של הנתונים.

4. הוראות התקנה והרצה — קוד שאפשר להעתיק ולהריץ. אם מגייס מנסה להריץ ולזה לא עובד, הוא זורק.

5. תוצאות ומטריקות — מספרים. טבלה עם Accuracy, F1, latency. לא "המודל עבד טוב." אלא "F1=0.91 על test set של 2,000 דוגמאות."

6. מה למדתם / מה הייתם עושים אחרת — זה מה שמפריד Junior מ-Senior. הנכונות לכתוב "ניסיתי X וזה לא עבד כי Y, אז עברתי ל-Z" שווה זהב.

כמה זמן לוקח לבנות את כל חמשת הפרויקטים?

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

פרויקט סיווג תמונות — שבועיים עד שלושה. פרויקט NLP / RAG — שלושה עד ארבעה שבועות. מערכת המלצות — שבועיים. Edge AI — שלושה שבועות (כולל עבודה עם חומרה). MLOps Pipeline — שלושה עד ארבעה שבועות.

זה הרבה עבודה? כן. אבל זה מה שמפריד בין מי שמדבר על AI לבין מי שבונה AI. ואף אחד לא הבטיח שזה יהיה קל. הבטחנו שזה יהיה שווה את זה.

תיק עבודות חזק של AI Engineer נבנה מחמישה פרויקטים שמכסים את כל הספקטרום: ראייה ממוחשבת, עיבוד שפה טבעית, מערכות המלצות, הרצה על חומרת קצה, ו-MLOps. כל פרויקט צריך להיות מתועד מקצועית ב-GitHub, עם קוד שרץ, מטריקות אמיתיות, ותובנות מהתהליך.

• התחילו מפרויקט סיווג התמונות — הוא הכי מובנה, הכי מתועד, והכי מהיר לסיום ראשוני.
• הוסיפו פרויקט RAG / NLP — זה התחום עם הביקוש הגדול ביותר בשוק כרגע.
• אל תדלגו על Edge AI — זה מבדיל אתכם מ-90% מהמועמדים בשוק הישראלי.
• השקיעו ב-README לפחות כמו בקוד — README שבור = פרויקט שאף אחד לא יסתכל עליו.
• בנו את ה-MLOps Pipeline אחרון — כי הוא יכול לעטוף אחד מהפרויקטים הקודמים ולהראות את כל הדרך מאימון עד פריסה.

עודכן: 2026-09-22

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

לא חייבים, אבל ככל שתיק העבודות מגוון יותר, הסיכויים עולים. אם הזמן מוגבל, תתעדפו לפי התפקיד שאתם מכוונים אליו: לתפקידי Computer Vision — פרויקט 1 ו-4. לתפקידי NLP — פרויקט 2. לתפקידי ML Engineer כללי — פרויקטים 3 ו-5 הם קריטיים.

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

אפשר, אבל עם סייגים. Kaggle notebook שמריץ מודל על dataset מוכן זה נחמד ללמידה, אבל מגייסים רוצים לראות שאתם יודעים לעבוד עם data אמיתי — מלוכלך, חסר, לא מאוזן. קחו תחרות של Kaggle כנקודת התחלה, אבל הוסיפו שכבת deployment, תיעוד מעמיק, וניתוח שגיאות.

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

Python היא הבחירה הברורה לרוב הפרויקטים — היא שפת הסטנדרט של תעשיית ה-ML/AI. לפרויקט Edge AI, ייתכן שתצטרכו גם C++ לאופטימיזציות ביצועים. לפרויקט MLOps, תוסיפו גם Bash scripting, Docker, ו-YAML. אין צורך לדעת את כל השפות מראש — לומדים תוך כדי בנייה.

איך מראים את הפרויקטים למגייסים אם אין לי ניסיון תעסוקתי?

שימו קישור ל-GitHub בראש קורות החיים, לפני כל דבר אחר. ב-LinkedIn, הצמידו את הפרויקטים כ-Featured Section. כשמגישים מועמדות, ציינו במייל: "בניתי מערכת RAG שרצה על 50,000 מסמכים עם latency של 200ms — הנה הקישור." ספציפיות מנצחת כותרות גנריות.

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

לפרויקטים 1 ו-2 כדאי מאוד. אבל לא חייבים להשקיע בחומרה: Google Colab מציע GPU חינמי, Kaggle Notebooks גם, ואפשר להשתמש ב-Lambda Cloud או Vast.ai לפי שעה. לפרויקט Edge AI תצטרכו חומרה פיזית — Raspberry Pi 5 עולה סביב 300 שקל בישראל, ו-NVIDIA Jetson Nano Orin סביב 800 שקל.

כמה זמן נדרש כדי ללמוד את הכלים הדרושים מאפס?

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

מה עדיף — הרבה פרויקטים קטנים או מעט פרויקטים מעמיקים?

מעט ומעמיקים. כל פעם. מגייס שרואה 20 רפוזיטוריז חצי-ריקים חושב "מתחיל שלא מסיים דברים." מגייס שרואה 5 רפוזיטוריז עם README מושקע, טסטים, ו-CI/CD חושב "פה יש מהנדס." עומק > רוחב, תמיד.

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

מקורות לימוד מומלצים

• קורסים: מסלול קורס AI Engineer המעניק הבנה מעמיקה בבנייה ואימון של מודלים למידת מכונה ולמידה עמוקה (Deep Learning), עבודה עם ארכיטקטורות Transformer, פיתוח אפליקציות מבוססות LLM (כמו RAG ו-Agents), ופריסת מודלים בסביבות ייצור (MLOps).

• בלוגים / פורומים: Hugging Face Blog, Distill.pub, OpenAI Research, Towards Data Science (Medium), Reddit (r/MachineLearning, r/LocalLLaMA).

• ספרים: Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow (של Aurélien Géron), Designing Machine Learning Systems (של Chip Huyen).

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