וקטורים ומרחבים (Vectors and Spaces)

למה זה חשוב

וקטורים הם השפה הבסיסית של Machine Learning. כל פיסת מידע -- תמונה, מילה, משפט, משתמש -- מיוצגת בסופו של דבר כ-וקטור: מערך של מספרים. בלי להבין וקטורים, אי אפשר להבין כיצד מודלים "רואים" את העולם.

• כל אלגוריתם ML מקבל וקטורים כקלט ומחזיר וקטורים כפלט.
• מרחבים רב-ממדיים (High-dimensional spaces) הם "המגרש" שבו המודלים עובדים.
• מדדי מרחק בין וקטורים הם הבסיס ל-Classification, Clustering, ו-Retrieval.

רעיונות מרכזיים

מהו וקטור?

וקטור הוא פשוט רשימה מסודרת של מספרים. כל מספר מייצג "תכונה" (Feature) כלשהי:

# וקטור שמייצג דירה: [שטח_במ"ר, מספר_חדרים, קומה, מרחק_מהים_בק"מ]
apartment = [85, 3.5, 4, 1.2]

מתמטית, וקטור ב-$\mathbb{R}^n$ הוא איבר במרחב $n$-ממדי:

$\mathbf{v} = \begin{pmatrix} v_1 \\ v_2 \\ \vdots \\ v_n \end{pmatrix} \in \mathbb{R}^n$

כל ממד (dimension) מייצג ציר אחד במרחב. וקטור בעל $n$ ממדים הוא נקודה (או חץ) במרחב $n$-ממדי.

פעולות בסיסיות על וקטורים

חיבור וקטורים -- חיבור רכיב-רכיב:

$\mathbf{a} + \mathbf{b} = \begin{pmatrix} a_1 + b_1 \\ a_2 + b_2 \\ \vdots \\ a_n + b_n \end{pmatrix}$

כפל בסקלר -- כפל כל רכיב במספר:

$c \cdot \mathbf{a} = \begin{pmatrix} c \cdot a_1 \\ c \cdot a_2 \\ \vdots \\ c \cdot a_n \end{pmatrix}$

מכפלה סקלרית (Dot Product) -- סכום מכפלות הרכיבים:

$\mathbf{a} \cdot \mathbf{b} = \sum_{i=1}^{n} a_i \cdot b_i = a_1 b_1 + a_2 b_2 + \ldots + a_n b_n$

import numpy as np

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# חיבור
print(a + b)            # [5, 7, 9]

# כפל בסקלר
print(2 * a)            # [2, 4, 6]

# Dot product
print(np.dot(a, b))     # 1*4 + 2*5 + 3*6 = 32

# נורמה (אורך)
print(np.linalg.norm(a))  # sqrt(1+4+9) = 3.742

נורמה (Norm) -- "אורך" הוקטור:

$||\mathbf{a}||_2 = \sqrt{\sum_{i=1}^{n} a_i^2}$

זו ה-L2 Norm (Euclidean Norm). קיימות גם נורמות אחרות:

• $||\mathbf{a}||_1 = \sum |a_i|$ -- L1 Norm (Manhattan Distance)
• $||\mathbf{a}||_\infty = \max |a_i|$ -- Infinity Norm

Feature Vectors

Feature Vector הוא וקטור שבו כל ממד מייצג תכונה שנבחרה או נלמדה:

• ב-Tabular data -- כל עמודה היא Feature.
• ב-NLP -- מילה יכולה להיות מיוצגת כ-Embedding vector (למשל Word2Vec, 300 ממדים).
• ב-Computer Vision -- תמונה עוברת דרך CNN ומתקבל וקטור שמייצג "את התוכן" שלה.

# דוגמה: Feature Vector עבור בית
# [שטח, חדרים, קומה, מרחק_מרכז, שנת_בנייה, יש_מעלית, יש_חניה]
house_features = np.array([120, 4, 2, 3.5, 2015, 1, 1])

# דוגמה: Feature Vector אחרי One-Hot Encoding
# [שטח, חדרים, עיר_תא=1, עיר_ירושלים=0, עיר_חיפה=0]
house_encoded = np.array([120, 4, 1, 0, 0])

Embeddings

Embedding הוא וקטור שנלמד על ידי מודל כך שפריטים דומים יהיו קרובים במרחב:

king  -> [0.2, 0.8, 0.1, ...]
queen -> [0.21, 0.79, 0.15, ...]
car   -> [0.9, 0.1, 0.7, ...]

האנלוגיות המפורסמות של Word2Vec:

אחד הדברים המפתיעים ביותר ב-Embeddings הוא שאפשר לעשות "אריתמטיקה" על מילים:

$\vec{king} - \vec{man} + \vec{woman} \approx \vec{queen}$

# בפועל עם מודל Word2Vec מאומן:
result = model["king"] - model["man"] + model["woman"]
# המילה הקרובה ביותר ל-result היא "queen"

מדדי מרחק (Distance Metrics)

כדי לדעת "כמה שני וקטורים דומים", משתמשים במדדי מרחק:

Euclidean Distance -- המרחק "הרגיל" בקו ישר:

$d(\mathbf{a}, \mathbf{b}) = \sqrt{\sum_{i=1}^{n}(a_i - b_i)^2}$

import numpy as np
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
dist = np.linalg.norm(a - b)  # = 5.196

Cosine Similarity -- מודד את הזווית בין שני וקטורים (לא את האורך):

$\text{cosine\_sim}(\mathbf{a}, \mathbf{b}) = \frac{\mathbf{a} \cdot \mathbf{b}}{||\mathbf{a}|| \cdot ||\mathbf{b}||}$

הערך נע בין $-1$ (כיוונים הפוכים) ל-$1$ (אותו כיוון). ערך $0$ משמעותו שהווקטורים ניצבים (אורתוגונליים -- "לא קשורים").

from numpy.linalg import norm
cos_sim = np.dot(a, b) / (norm(a) * norm(b))  # = 0.974

Manhattan Distance (L1) -- סכום ההפרשים המוחלטים:

$d_{L1}(\mathbf{a}, \mathbf{b}) = \sum_{i=1}^{n} |a_i - b_i|$

מרחבים רב-ממדיים (High-Dimensional Spaces)

במציאות, וקטורים ב-ML הם בעלי מאות עד אלפי ממדים:

• Word Embeddings: 300 ממדים
• BERT Embeddings: 768 ממדים
• GPT Embeddings: 1536+ ממדים

אינטואיציה: מה קורה במרחבים גבוהים?

דמיינו קוביית יחידה ב-$n$ ממדים. כמה מהנפח שלה "קרוב" לפינות לעומת המרכז?

• ב-2D: רוב השטח קרוב למרכז
• ב-100D: כמעט כל הנפח נמצא בפינות!

$\text{Volume of inscribed sphere} / \text{Volume of cube} \xrightarrow{n \to \infty} 0$

זה אומר שב-High dimensions, נקודות "מתנפחות" לפינות, מרחקים הופכים דומים, ואינטואיציה מ-2D/3D מטעה אותנו.

Dimensionality Reduction

כדי להתמודד עם Curse of Dimensionality ולהמחיש נתונים, משתמשים בטכניקות הקטנת ממדים:

PCA (Principal Component Analysis) -- מוצא את הצירים שלאורכם יש הכי הרבה שונות (variance):

from sklearn.decomposition import PCA

# נתונים ב-768 ממדים (BERT Embeddings)
X = np.random.randn(1000, 768)

# הקטנה ל-2 ממדים להמחשה
pca = PCA(n_components=2)
X_2d = pca.fit_transform(X)

# כמה מהמידע נשמר?
print(f"Explained variance: {pca.explained_variance_ratio_.sum():.2%}")

t-SNE -- שומר על יחסי שכנות (מי קרוב למי), מצוין לויזואליזציה:

from sklearn.manifold import TSNE

tsne = TSNE(n_components=2, perplexity=30)
X_2d = tsne.fit_transform(X)

Vector Databases -- חיפוש וקטורי

אחד השימושים החמים ביותר של וקטורים היום הוא Vector Search -- חיפוש הפריטים הדומים ביותר לוקטור נתון:

# Semantic Search -- חיפוש לפי משמעות
query = "איך מכינים עוגת שוקולד?"
query_embedding = encode(query)  # [0.23, 0.87, -0.12, ...]

# חיפוש ב-Vector DB: מוצאים את ה-embeddings הקרובים ביותר
results = vector_db.search(query_embedding, top_k=5)
# מחזיר: מתכוני שוקולד, גם אם המילה "שוקולד" לא מופיעה בדיוק

מאגרי Vector DB פופולריים: Pinecone, Weaviate, Qdrant, FAISS (מ-Meta), Chroma.

בלבולים נפוצים

• "וקטור = חץ בפיזיקה" -- ב-ML, וקטור הוא בעיקר מערך מספרים. אין צורך לחשוב על כיוון וגודל כמו בפיזיקה.
• "Cosine Similarity ו-Euclidean Distance נותנים את אותה תשובה" -- לא! Cosine מתעלם מאורך הוקטור, Euclidean לא. שני וקטורים באותו כיוון אבל באורכים שונים יהיו דומים ב-Cosine אבל רחוקים ב-Euclidean.
• "יותר ממדים = יותר טוב" -- לא בהכרח. ממדים מיותרים מוסיפים רעש ומאטים חישובים.
• "Embedding ו-Feature Vector זה אותו דבר" -- Feature Vector יכול להיות ידני, Embedding תמיד נלמד ע"י מודל.
• "Dot Product ו-Cosine Similarity זה אותו דבר" -- Cosine Similarity הוא Dot Product מנורמל. אם הוקטורים מנורמלים (אורך 1), אז הם שקולים. אחרת -- לא.

דוגמה קטנה

נניח שאנחנו רוצים למצוא את המילה הכי דומה ל-"מלך" מתוך רשימה:

import numpy as np

# Embeddings פשוטים (בפועל יש הרבה יותר ממדים)
words = {
    "מלך":    np.array([0.9, 0.1, 0.8, 0.2]),
    "מלכה":   np.array([0.85, 0.15, 0.75, 0.6]),
    "חתול":   np.array([0.1, 0.9, 0.2, 0.3]),
    "נסיך":   np.array([0.88, 0.12, 0.7, 0.25]),
}

target = words["מלך"]

for word, vec in words.items():
    if word == "מלך":
        continue
    cos_sim = np.dot(target, vec) / (np.linalg.norm(target) * np.linalg.norm(vec))
    euc_dist = np.linalg.norm(target - vec)
    print(f"{word}: cosine similarity = {cos_sim:.3f}, euclidean distance = {euc_dist:.3f}")

# פלט:
# מלכה: cosine similarity = 0.965, euclidean distance = 0.430
# חתול: cosine similarity = 0.438, euclidean distance = 1.262
# נסיך: cosine similarity = 0.997, euclidean distance = 0.112

📚 לימוד אקדמי

🛤️ מאיפה מתחילים

1. בסיס מתמטי -- ודאו שאתם מרגישים בנוח עם אלגברה לינארית בסיסית: וקטורים, מכפלה סקלרית, נורמות. קורס מומלץ: 3Blue1Brown -- Essence of Linear Algebra (YouTube).
2. NumPy -- תרגלו יצירה ומניפולציה של וקטורים ב-NumPy. זה הכלי היום-יומי.
3. מדדי מרחק -- ממשו Euclidean Distance ו-Cosine Similarity ידנית (בלי ספריות), ואז השוו לפונקציות של scipy.spatial.distance.
4. Embeddings -- שחקו עם Word2Vec או GloVe מוכנים מ-gensim. חפשו אנלוגיות (king - man + woman = ?) ובדקו similarity בין מילים.
5. ויזואליזציה -- קחו Embeddings של מילים/מסמכים, הקטינו ל-2D עם t-SNE או PCA, ותראו Clusters.
6. Vector Search -- נסו Chroma או FAISS ותבנו Semantic Search פשוט על קובץ טקסט.
7. פרויקט -- בנו RAG פשוט: קחו מסמך, חלקו לפסקאות, צרו Embeddings עם OpenAI/Sentence-Transformers, אחסנו ב-Vector DB, וחפשו תשובות לשאלות.

💼 שאלות לראיון עבודה

קישורים לנושאים אחרים

• סיווג (Classification) -- שימוש בוקטורים כקלט לאלגוריתמי סיווג
• אלגוריתמים ב-ML -- KNN, K-Means ואלגוריתמים נוספים שעובדים ישירות על וקטורים
• Transformers -- מנגנון ה-Attention מבוסס כולו על Dot Products בין וקטורים
• Loss & Softmax -- איך ה-Loss Function מנחה את למידת ה-Embeddings