🔴 Сложный ⏱️ 90 минут

Векторы: от математики до нейронных сетей

Векторы: от математики до нейронных сетей 📊

Если ты работаешь с AI, ML или просто интересуешься нейронными сетями, то ты уже сталкивался с векторами — даже если не знал об этом. Каждый раз, когда ChatGPT понимает смысл твоего вопроса, когда рекомендательная система предлагает тебе фильм, когда система распознавания лиц находит тебя на фото — за всем этим стоят векторы.

Представь: ты вводишь запрос в поисковик “как обучить нейросеть”. Система не просто ищет точное совпадение слов — она понимает СМЫСЛ твоего запроса. Как? Она превращает твой текст в вектор (список чисел вроде [0.23, -0.45, 0.89, ...]) и сравнивает его с векторами других документов. Документы с похожими векторами — это документы с похожим смыслом!

Это и есть магия векторов в ML. Они позволяют превратить что угодно — слова, картинки, звуки — в числа, с которыми компьютер может работать. И самое крутое: операции над этими числами имеют реальный смысл! Сложение векторов = комбинация признаков. Расстояние между векторами = насколько объекты похожи.

В этом уроке мы пройдём путь от самых основ (что такое вектор?) до реального применения в ML. Ты поймёшь:

🎯 Что такое векторы и почему они фундамент всего ML/AI
🎯 Как складывать, вычитать и умножать векторы (и зачем это в нейросетях)
🎯 Что такое embeddings и как они работают в GPT/BERT
🎯 Как измерять похожесть объектов через косинусное расстояние
🎯 Почему нормализация векторов критична для обучения моделей
🎯 Как применять всё это на практике в реальных ML-задачах

Готов? Поехали разбираться! 🚀

Что такое вектор: от стрелочки до embedding’а

Интуитивное понимание

Давай начнём с самого простого. Забудь пока про нейросети — представь, что ты описываешь квартиру для сайта недвижимости. Что важно? Площадь, количество комнат, этаж, цена. Получается такая карточка:

Квартира А:
- Площадь: 50 м²
- Комнат: 2
- Этаж: 5
- Цена: 8 млн ₽

Можем записать это как список чисел: [50, 2, 5, 8000000]. Поздравляю — ты только что создал вектор! Вектор — это просто упорядоченный список чисел, где каждое число — это какая-то характеристика объекта.

Теперь представь, что у тебя есть ещё одна квартира:

Квартира Б:
[52, 2, 6, 8200000]

Видишь, что эти квартиры похожи? Их векторы близки! А вот квартира [120, 4, 1, 25000000] — совсем другая история.

В ML это называется feature vector (вектор признаков). Каждый объект (квартира, пользователь, текст, картинка) описывается набором чисел. И чем ближе векторы, тем больше похожи объекты.

Геометрическое понимание (классическое)

В математике вектор часто представляют как стрелку в пространстве. Почему стрелку? Потому что у вектора есть: - Направление (куда показывает) - Длина (насколько далеко)

Вот вектор на плоскости:

      B (3, 4)
      ↑
     /|
    / |
   /  |  вектор AB = [3, 4]
  /   |
 /    |
A (0, 0)

Этот вектор можно записать как AB = [3, 4] или просто v = (3, 4). Что это значит? - Первое число (3) — это сдвиг по оси X (вправо) - Второе число (4) — это сдвиг по оси Y (вверх)

В 3D-пространстве добавляется третья координата:

v = [x, y, z] = [3, 4, 5]

В ML пространства могут быть огромными! Например, word2vec создаёт векторы слов из 300 чисел. BERT использует 768 чисел. GPT-3 — 12288 чисел! Мы не можем нарисовать 768-мерное пространство, но математика работает точно так же.

Строгое определение

Определение: Вектор — это элемент векторного пространства, который можно представить как упорядоченный набор $n$ действительных чисел:

$$\vec{v} = (v_1, v_2, v_3, …, v_n)$$

где $n$ — размерность вектора (количество координат).

Обозначения: - $\vec{v}$ или $\mathbf{v}$ — вектор (стрелка или жирный шрифт) - $v_i$ — $i$-я компонента (координата) вектора - $n$ — размерность вектора - $\mathbb{R}^n$ — пространство всех $n$-мерных векторов

Примеры: - 2D вектор: $\vec{v} = (2, 3) \in \mathbb{R}^2$ - 3D вектор: $\vec{v} = (1, -2, 4) \in \mathbb{R}^3$ - 768D embedding: $\vec{v} = (0.23, -0.45, …, 0.12) \in \mathbb{R}^{768}$

Почему это важно для ML

Векторы — это язык машинного обучения. Вот почему:

  1. Унификация данных: Любой объект (текст, картинка, звук) можно превратить в вектор. Это позволяет работать с разными типами данных единообразно.

  2. Математические операции: Над векторами можно выполнять операции (сложение, умножение), которые имеют реальный смысл. Например:

    вектор("король") - вектор("мужчина") + вектор("женщина") ≈ вектор("королева")

    Это не магия — это линейная алгебра!

  3. Измерение похожести: Расстояние между векторами показывает, насколько похожи объекты. Это основа рекомендательных систем, поиска, кластеризации.

  4. Обучение моделей: Нейронные сети принимают на вход векторы и выдают векторы. Всё обучение — это поиск правильных преобразований векторов.

Операции с векторами: строим интуицию

Сложение векторов

Что это такое простыми словами:

Представь, что у тебя есть два признака пользователя:

user_interests = [0.8, 0.3, 0.1]  # [техника, спорт, кулинария]
user_behavior = [0.5, 0.2, 0.6]   # [читает долго, кликает быстро, покупает]

Когда ты складываешь эти векторы, ты комбинируешь информацию:

combined = [0.8+0.5, 0.3+0.2, 0.1+0.6] = [1.3, 0.5, 0.7]

Получается более полный профиль пользователя!

Геометрически сложение векторов — это последовательное применение сдвигов:

      C
      ↑
     /|
    / |  вектор b
   /  |
  B   |
  ↑   |
  |   |  вектор a
  |   |
  A---→

вектор c = a + b (результат)

Формула:

$$\vec{a} + \vec{b} = (a_1 + b_1, a_2 + b_2, …, a_n + b_n)$$

Складываем покомпонентно (каждую координату отдельно).

Пример 1 (простой):

Два вектора на плоскости: - $\vec{a} = (2, 3)$ - $\vec{b} = (1, 4)$

Решение:

Шаг 1: Складываем первые координаты:

a₁ + b₁ = 2 + 1 = 3

Шаг 2: Складываем вторые координаты:

a₂ + b₂ = 3 + 4 = 7

Шаг 3: Собираем результат:

a + b = (3, 7)

Ответ: $(3, 7)$

Пример 2 (ML: комбинирование embeddings):

У тебя есть два word embedding:

word1 = [0.5, -0.3, 0.8]   # embedding слова "умный"
word2 = [0.2, 0.6, -0.1]   # embedding слова "быстрый"

Ты хочешь получить признаки для фразы “умный и быстрый”.

Решение:

Шаг 1: Складываем покомпонентно:

combined = [
    0.5 + 0.2,      # первая координата
    -0.3 + 0.6,     # вторая координата
    0.8 + (-0.1)    # третья координата
]

Шаг 2: Вычисляем:

combined = [0.7, 0.3, 0.7]

Зачем это нужно? В простых моделях (bag-of-words) мы часто суммируем embeddings всех слов в предложении, чтобы получить embedding всего предложения. Это примитивно, но работает!

Ответ: [0.7, 0.3, 0.7]

Пример 3 (сложный: batch processing в нейросети):

У тебя есть батч из 3 примеров (каждый — вектор признаков):

batch = [
    [1.0, 2.0, 3.0],  # пример 1
    [0.5, 1.5, 2.5],  # пример 2
    [2.0, 3.0, 4.0]   # пример 3
]

Ты хочешь посчитать среднее по батчу (это часто делается для batch normalization).

Решение:

Шаг 1: Сложим все векторы:

sum_vector = [1.0 + 0.5 + 2.0,
              2.0 + 1.5 + 3.0,
              3.0 + 2.5 + 4.0]
           = [3.5, 6.5, 9.5]

Шаг 2: Разделим на количество примеров (3):

mean = [3.5/3, 6.5/3, 9.5/3]
     = [1.167, 2.167, 3.167]

Зачем это? В batch normalization мы нормализуем данные, вычитая среднее по батчу. Это стабилизирует обучение.

Ответ: [1.167, 2.167, 3.167]

Вычитание векторов

Что это такое простыми словами:

Вычитание показывает разницу между объектами. Например:

new_user = [0.8, 0.5, 0.3]  # признаки нового пользователя
avg_user = [0.6, 0.4, 0.5]  # средний пользователь

difference = new_user - avg_user = [0.2, 0.1, -0.2]

Положительные значения — где новый пользователь выше среднего. Отрицательные — где ниже. Это отклонение от нормы!

Формула:

$$\vec{a} - \vec{b} = (a_1 - b_1, a_2 - b_2, …, a_n - b_n)$$

Геометрически: вектор $\vec{a} - \vec{b}$ — это вектор от конца $\vec{b}$ к концу $\vec{a}$.

Пример 4 (ML: residual в ResNet):

В ResNet архитектуре используется идея residual connections. Сеть учится предсказывать не сам выход, а разницу (residual):

input_features = [2.0, 3.0, 1.5]    # вход в слой
output_features = [2.3, 3.5, 1.8]   # выход слоя

# Residual = выход - вход
residual = [2.3 - 2.0,
            3.5 - 3.0,
            1.8 - 1.5]
         = [0.3, 0.5, 0.3]

Зачем? Учить добавку (residual) проще, чем учить полное преобразование. Это позволяет обучать очень глубокие сети (100+ слоёв).

Ответ: [0.3, 0.5, 0.3]

Умножение вектора на число (скаляр)

Что это такое простыми словами:

Умножение на число масштабирует вектор. Например, у тебя есть признаки пользователя:

user_features = [0.5, 0.8, 0.3]

Ты хочешь сделать их более выраженными (увеличить в 2 раза):

scaled = 2 * user_features = [1.0, 1.6, 0.6]

Или ослабить (умножить на 0.5):

scaled = 0.5 * user_features = [0.25, 0.4, 0.15]

Формула:

$$k \cdot \vec{v} = (k \cdot v_1, k \cdot v_2, …, k \cdot v_n)$$

где $k$ — число (скаляр).

Пример 5 (ML: learning rate в градиентном спуске):

У тебя есть градиент (направление, куда двигать веса модели):

gradient = [0.3, -0.5, 0.8]

Ты не хочешь делать слишком большой шаг, поэтому умножаешь на learning rate (например, 0.01):

Решение:

step = 0.01 * gradient
     = [0.01 * 0.3,
        0.01 * (-0.5),
        0.01 * 0.8]
     = [0.003, -0.005, 0.008]

Теперь обновляем веса:

new_weights = old_weights - step

Зачем нужен learning rate? Если делать полный шаг по градиенту, можно “перепрыгнуть” минимум. Малый learning rate = осторожные, стабильные шаги.

Ответ: [0.003, -0.005, 0.008]

Скалярное произведение (dot product)

Это самая важная операция в ML! Серьёзно, 90% вычислений в нейросетях — это dot product.

Что это такое простыми словами:

Скалярное произведение показывает, насколько векторы “смотрят в одну сторону”. Если dot product большой и положительный — векторы похожи. Если близок к нулю — векторы ортогональны (независимы). Если отрицательный — векторы противоположны.

Формула:

$$\vec{a} \cdot \vec{b} = a_1 b_1 + a_2 b_2 + … + a_n bn = \sum{i=1}^{n} a_i b_i$$

Альтернативная формула (через угол):

$$\vec{a} \cdot \vec{b} = |\vec{a}| \cdot |\vec{b}| \cdot \cos(\theta)$$

где $\theta$ — угол между векторами.

Пример 6 (простой):

Два вектора: - $\vec{a} = (2, 3)$ - $\vec{b} = (4, 1)$

Решение:

Шаг 1: Умножаем соответствующие координаты:

a₁ × b₁ = 2 × 4 = 8
a₂ × b₂ = 3 × 1 = 3

Шаг 2: Складываем результаты:

a · b = 8 + 3 = 11

Ответ: $11$

Пример 7 (ML: similarity между embeddings):

У тебя есть embedding двух слов:

word1 = [0.8, 0.6, 0.2]   # "кот"
word2 = [0.9, 0.5, 0.3]   # "котёнок"

Ты хочешь понять, насколько они похожи.

Решение:

Шаг 1: Вычисляем dot product:

similarity = (0.8 × 0.9) + (0.6 × 0.5) + (0.2 × 0.3)
           = 0.72 + 0.30 + 0.06
           = 1.08

Шаг 2: Интерпретируем: - Значение 1.08 — это высокая похожесть! - Сравним с другой парой:

  word3 = [0.1, -0.2, 0.9]  # "машина"
  similarity2 = (0.8 × 0.1) + (0.6 × -0.2) + (0.2 × 0.9)
              = 0.08 - 0.12 + 0.18
              = 0.14

“Кот” и “машина” гораздо менее похожи!

Ответ: 1.08 (высокая похожесть)

Пример 8 (сложный: forward pass в нейронной сети):

Ты передаёшь вход через один нейрон. Нейрон имеет веса и bias:

input_vector = [1.0, 2.0, 3.0]
weights = [0.5, -0.3, 0.8]
bias = 0.2

Решение:

Шаг 1: Вычисляем dot product входа и весов:

dot = (1.0 × 0.5) + (2.0 × -0.3) + (3.0 × 0.8)
    = 0.5 - 0.6 + 2.4
    = 2.3

Шаг 2: Добавляем bias:

pre_activation = dot + bias
               = 2.3 + 0.2
               = 2.5

Шаг 3: Применяем функцию активации (ReLU):

output = max(0, pre_activation)
       = max(0, 2.5)
       = 2.5

Вот и всё! Один нейрон вычислил свой выход. В сети могут быть миллионы таких операций.

Ответ: 2.5

Длина (норма) вектора

Что это такое простыми словами:

Длина вектора — это его “размер”. В ML это часто называют magnitude или norm.

Формула (евклидова норма L2):

$$||\vec{v}|| = \sqrt{v_1^2 + v_2^2 + … + v_n^2}$$

Пример 9 (простой):

Найди длину вектора $\vec{v} = (3, 4)$.

Решение:

Шаг 1: Возводим каждую координату в квадрат:

3² = 9
4² = 16

Шаг 2: Складываем:

9 + 16 = 25

Шаг 3: Извлекаем корень:

√25 = 5

Ответ: $5$

Пример 10 (ML: нормализация embedding):

У тебя есть embedding:

embedding = [3, 4, 0]

Ты хочешь нормализовать его (сделать длину = 1). Это важно для cosine similarity!

Решение:

Шаг 1: Находим длину:

length = sqrt(3² + 4² + 0²)
       = sqrt(9 + 16 + 0)
       = sqrt(25)
       = 5

Шаг 2: Делим каждую координату на длину:

normalized = [3/5, 4/5, 0/5]
           = [0.6, 0.8, 0]

Шаг 3: Проверяем, что длина теперь = 1:

length_check = sqrt(0.6² + 0.8² + 0²)
             = sqrt(0.36 + 0.64 + 0)
             = sqrt(1)
             = 1  ✓

Зачем нормализовать? После нормализации dot product = cosine similarity. Это позволяет сравнивать векторы только по направлению, игнорируя длину.

Ответ: [0.6, 0.8, 0]

Применение в ML: embeddings и similarity

Что такое embeddings

Простыми словами:

Embedding — это представление объекта в виде вектора. Ты берёшь что-то сложное (слово, предложение, картинку) и превращаешь в список чисел, с которым можно работать математически.

Примеры: - Word embeddings: “кот” → [0.8, -0.3, 0.5, ...] (300 чисел) - Sentence embeddings: “Я люблю машинное обучение” → [0.2, 0.7, ...] (768 чисел) - Image embeddings: фото кота → [0.1, 0.9, ...] (2048 чисел) - User embeddings: профиль пользователя → [0.3, 0.5, ...] (128 чисел)

Ключевая идея: Похожие объекты имеют похожие embeddings!

Как создаются embeddings:

  1. Word2Vec/GloVe — алгоритмы, которые обучаются на больших текстах. Они наблюдают, какие слова встречаются рядом, и строят векторы так, чтобы похожие слова были близко.

  2. BERT/GPT — трансформеры, которые создают контекстуальные embeddings. Одно и то же слово может иметь разные embeddings в зависимости от контекста!

  3. ResNet/Vision Transformers — для картинок. Берут изображение, прогоняют через нейросеть, и последний слой — это embedding.

Cosine similarity: как измерять похожесть

Проблема с dot product:

Представь два embedding:

v1 = [1, 2, 3]
v2 = [10, 20, 30]

Вектор v2 — это просто v1 × 10. Они указывают в одном направлении (полностью похожи), но dot product будет огромным просто из-за разных масштабов!

Решение: Cosine similarity — измеряем угол между векторами, игнорируя длину.

Формула:

$$\text{cosine_similarity}(\vec{a}, \vec{b}) = \frac{\vec{a} \cdot \vec{b}}{||\vec{a}|| \cdot ||\vec{b}||}$$

Это нормализованный dot product. Значение всегда от -1 до 1: - 1 = векторы полностью совпадают по направлению - 0 = векторы ортогональны (независимы) - -1 = векторы противоположны

Пример 11 (ML: поиск похожих документов):

У тебя есть embeddings трёх документов:

doc1 = [2, 3, 1]      # "машинное обучение"
doc2 = [4, 6, 2]      # "нейронные сети и ML"
doc3 = [1, -2, 5]     # "история Египта"

Ты хочешь найти, какой документ наиболее похож на doc1.

Решение:

Шаг 1: Вычисляем длины:

||doc1|| = sqrt(2² + 3² + 1²) = sqrt(4 + 9 + 1) = sqrt(14) ≈ 3.74
||doc2|| = sqrt(4² + 6² + 2²) = sqrt(16 + 36 + 4) = sqrt(56) ≈ 7.48
||doc3|| = sqrt(1² + (-2)² + 5²) = sqrt(1 + 4 + 25) = sqrt(30) ≈ 5.48

Шаг 2: Вычисляем dot products:

doc1 · doc2 = (2×4) + (3×6) + (1×2) = 8 + 18 + 2 = 28
doc1 · doc3 = (2×1) + (3×-2) + (1×5) = 2 - 6 + 5 = 1

Шаг 3: Вычисляем cosine similarity:

sim(doc1, doc2) = 28 / (3.74 × 7.48) = 28 / 27.98 ≈ 1.00
sim(doc1, doc3) = 1 / (3.74 × 5.48) = 1 / 20.49 ≈ 0.05

Шаг 4: Интерпретируем: - doc2 почти идентичен doc1 (similarity ≈ 1.0)! - doc3 почти не связан с doc1 (similarity ≈ 0.05)

Вывод: Документ 2 — это про машинное обучение (как и doc1), а документ 3 — про Египет (совсем другое).

Ответ: doc2 наиболее похож (similarity ≈ 1.0)

Пример 12 (сложный: рекомендательная система):

У тебя есть embeddings пользователей и фильмов. Ты хочешь предсказать, понравится ли пользователю фильм.

user_embedding = [0.8, 0.3, -0.5, 0.2]
movie1_embedding = [0.7, 0.4, -0.4, 0.3]  # "Матрица"
movie2_embedding = [-0.2, 0.9, 0.6, -0.1]  # "Титаник"

Решение:

Шаг 1: Вычисляем similarity с “Матрицей”:

dot1 = (0.8×0.7) + (0.3×0.4) + (-0.5×-0.4) + (0.2×0.3)
     = 0.56 + 0.12 + 0.20 + 0.06
     = 0.94

||user|| = sqrt(0.8² + 0.3² + 0.5² + 0.2²) = sqrt(1.02) ≈ 1.01
||movie1|| = sqrt(0.7² + 0.4² + 0.4² + 0.3²) = sqrt(0.74) ≈ 0.86

sim1 = 0.94 / (1.01 × 0.86) = 0.94 / 0.87 ≈ 1.08

Wait, больше 1? Значит я ошибся в вычислениях. Пересчитаем:

||user|| = sqrt(0.64 + 0.09 + 0.25 + 0.04) = sqrt(1.02) ≈ 1.01
||movie1|| = sqrt(0.49 + 0.16 + 0.16 + 0.09) = sqrt(0.90) ≈ 0.95

sim1 = 0.94 / (1.01 × 0.95) = 0.94 / 0.96 ≈ 0.98

Шаг 2: Вычисляем similarity с “Титаником”:

dot2 = (0.8×-0.2) + (0.3×0.9) + (-0.5×0.6) + (0.2×-0.1)
     = -0.16 + 0.27 - 0.30 - 0.02
     = -0.21

||movie2|| = sqrt(0.04 + 0.81 + 0.36 + 0.01) = sqrt(1.22) ≈ 1.10

sim2 = -0.21 / (1.01 × 1.10) = -0.21 / 1.11 ≈ -0.19

Шаг 3: Интерпретируем: - “Матрица”: similarity ≈ 0.98 — очень высокая, пользователю понравится! - “Титаник”: similarity ≈ -0.19 — отрицательная, скорее всего не понравится

Вывод: Рекомендуем “Матрицу”, не рекомендуем “Титаник”.

Ответ: “Матрица” с вероятностью 0.98

Euclidean distance: альтернативный способ

Кроме cosine similarity, есть евклидово расстояние (L2 distance):

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

Это “обычное” расстояние между точками, как в геометрии.

Когда использовать: - Cosine similarity: Когда важно направление (текст, семантика) - Euclidean distance: Когда важна абсолютная близость (координаты, физические величины)

Пример 13 (сравнение методов):

Два набора точек:

a1 = [1, 2]
b1 = [2, 4]  # это a1 × 2 (то же направление, но дальше)

a2 = [1, 2]
b2 = [2, 3]  # сдвиг по диагонали

Cosine similarity:

sim(a1, b1) ≈ 1.0   # почти идеальное совпадение направления
sim(a2, b2) ≈ 0.99  # тоже почти идеально

Euclidean distance:

dist(a1, b1) = sqrt((2-1)² + (4-2)²) = sqrt(1 + 4) = sqrt(5) ≈ 2.24
dist(a2, b2) = sqrt((2-1)² + (3-2)²) = sqrt(1 + 1) = sqrt(2) ≈ 1.41

Вывод: Cosine similarity считает оба случая почти одинаковыми (направления похожи), а euclidean distance видит разницу в абсолютных расстояниях.

Ответ: Зависит от задачи — выбирай метрику под свои цели!

Практика: 30 заданий

Базовые (задания 1-10)

Задание 1: Даны векторы $\vec{a} = (3, 5)$ и $\vec{b} = (2, 1)$. Найди $\vec{a} + \vec{b}$.

Задание 2: Найди длину вектора $\vec{v} = (6, 8)$.

Задание 3: Умножь вектор $\vec{v} = (2, -3, 4)$ на скаляр $k = 3$.

Задание 4: Вычисли dot product векторов $\vec{a} = (1, 2, 3)$ и $\vec{b} = (4, 5, 6)$.

Задание 5: Даны векторы $\vec{a} = (7, 2)$ и $\vec{b} = (3, 5)$. Найди $\vec{a} - \vec{b}$.

Задание 6: Нормализуй вектор $\vec{v} = (0, 3, 4)$ (сделай его длину равной 1).

Задание 7: У тебя есть embedding слова [0.5, 0.5]. Увеличь его “интенсивность” в 4 раза.

Задание 8: Вычисли евклидово расстояние между точками $A = (1, 2)$ и $B = (4, 6)$.

Задание 9: Даны три вектора: $\vec{a} = (1, 0)$, $\vec{b} = (0, 1)$, $\vec{c} = (1, 1)$. Найди $\vec{a} + \vec{b} + \vec{c}$.

Задание 10: У тебя есть градиент $\vec{g} = [0.8, -0.6, 1.2]$ и learning rate $\alpha = 0.1$. Вычисли шаг обновления: $\alpha \vec{g}$.

Средние (задания 11-20)

Задание 11: Вычисли cosine similarity между векторами $\vec{a} = (1, 2)$ и $\vec{b} = (2, 1)$.

Задание 12: У тебя есть два embedding: user = [0.6, 0.8] и item = [0.8, 0.6]. Предскажи, понравится ли item пользователю (используй cosine similarity).

Задание 13: Вычисли среднее (mean) трёх векторов: v1 = [1, 2, 3], v2 = [4, 5, 6], v3 = [7, 8, 9].

Задание 14: Ты обучаешь модель. Текущие веса: w = [1.0, 2.0, 3.0]. Градиент: g = [0.2, -0.1, 0.3]. Learning rate: lr = 0.5. Обнови веса: w_new = w - lr × g.

Задание 15: У тебя есть батч из 2 примеров: x1 = [2, 4], x2 = [6, 8]. Вычисли batch mean (среднее по батчу).

Задание 16: Найди проекцию вектора $\vec{a} = (3, 4)$ на вектор $\vec{b} = (1, 0)$ (единичный вектор по оси X).

Задание 17: Вычисли L1 distance (Manhattan distance) между векторами $\vec{a} = (1, 2, 3)$ и $\vec{b} = (4, 5, 6)$.

Задание 18: У тебя есть embedding документа [0.3, 0.4, 0.5]. Примени L2 normalization (нормализуй до длины 1).

Задание 19: Вычисли угол между векторами $\vec{a} = (1, 0)$ и $\vec{b} = (1, 1)$ (в градусах).

Задание 20: У тебя есть два класса объектов. Класс A: векторы близкие к [1, 1]. Класс B: векторы близкие к [-1, -1]. Определи класс вектора [0.8, 0.9] через cosine similarity.

Продвинутые (задания 21-30)

Задание 21: Реализуй forward pass линейного слоя (без bias). Вход: x = [1, 2, 3], веса: W = [[0.1, 0.2], [0.3, 0.4], [0.5, 0.6]]. Вычисли выход y = x^T × W.

Задание 22: У тебя есть query [1, 2] и три keys: k1 = [2, 1], k2 = [1, 1], k3 = [-1, 2]. Вычисли attention scores (dot products с query), потом примени softmax.

Задание 23: Реализуй batch normalization. Батч: [[1, 2], [3, 4], [5, 6]]. Вычисли mean и std по батчу, потом нормализуй.

Задание 24: Вычисли cross-entropy loss между предсказаниями pred = [0.7, 0.2, 0.1] и истинными метками true = [1, 0, 0] (one-hot encoded).

Задание 25: Найди nearest neighbors для вектора query = [0.5, 0.5, 0.5] среди векторов: v1 = [0.6, 0.4, 0.5], v2 = [0.1, 0.9, 0.2], v3 = [0.5, 0.5, 0.6]. Используй cosine similarity.

Задание 26: Реализуй momentum SGD. Текущие веса: w = [1, 2], градиент: g = [0.5, -0.3], текущий velocity: v = [0.1, 0.05], learning rate: lr = 0.1, momentum: m = 0.9. Обнови velocity и веса.

Задание 27: У тебя есть embeddings 5 слов (2D для простоты): words = [[1,0], [0.9,0.1], [0,1], [-0.1,0.9], [-1,0]]. Выполни K-means кластеризацию с K=2 (1 итерация). Начальные центроиды: c1 = [1,0], c2 = [0,1].

Задание 28: Реализуй dropout (вероятность drop = 0.5) на векторе x = [2, 4, 6, 8]. Используй маску mask = [1, 0, 1, 0] (1 = keep, 0 = drop). Не забудь rescale!

Задание 29: Вычисли Jaccard similarity между двумя множествами (представленными как бинарные векторы): A = [1, 1, 0, 1, 0], B = [1, 0, 1, 1, 0].

Задание 30 (комплексное): Ты строишь поисковую систему. У тебя есть 3 документа:

doc1 = "машинное обучение и нейронные сети"
doc2 = "глубокое обучение с нейронными сетями"
doc3 = "программирование на Python"

Представь каждый документ как TF-IDF вектор (упрощённо: считай частоты слов), потом найди наиболее релевантный документ для запроса "нейронные сети".

Частые ошибки

❌ Ошибка 1: Забывают нормализовать векторы перед cosine similarity
Неправильно: Считают dot product напрямую и думают, что это cosine similarity.
Правильно: Cosine similarity = dot product / (||a|| × ||b||). Без нормализации результат зависит от масштаба векторов!
Почему важно: В ML/NLP embeddings часто имеют разные масштабы. Без нормализации ты сравниваешь не “направления”, а “абсолютные размеры”, что неправильно.

❌ Ошибка 2: Путают L1 и L2 normы
Неправильно: Используют sqrt(|v₁| + |v₂| + …) или просто (|v₁| + |v₂| + …).
Правильно:
- L2 (евклидова): sqrt(v₁² + v₂² + …)
- L1 (Manhattan): |v₁| + |v₂| + …
Почему важно: L1 и L2 дают разные результаты. В ML L2 чаще используется для нормализации (unit vectors), L1 — для sparse features или regularization.

❌ Ошибка 3: Не масштабируют шаг градиента (learning rate)
Неправильно: Обновляют веса так: w_new = w - gradient.
Правильно: w_new = w - learning_rate × gradient.
Почему важно: Градиент показывает направление, но его величина может быть огромной. Без learning rate модель делает слишком большие шаги и расходится (loss → infinity).

❌ Ошибка 4: Складывают векторы разной размерности
Неправильно: Пытаются сложить [1, 2, 3] и [4, 5].
Правильно: Векторы должны иметь одинаковую размерность. Если нет — нужно padding (добавить нули) или truncation (обрезать).
Почему важно: Математически операция не определена для векторов разной размерности. Код просто упадёт с ошибкой.

❌ Ошибка 5: Не понимают разницу между row и column векторами
Неправильно: Путают умножение x × W и W × x, думая, что это одно и то же.
Правильно:
- x × W (row vector × matrix) — часто в ML (батч примеров)
- W × x (matrix × column vector) — классическая математика
Результаты разные!
Почему важно: В PyTorch/NumPy порядок умножения критичен. Неправильный порядок → неправильные размерности → ошибка.

❌ Ошибка 6: Не применяют rescaling после dropout
Неправильно: Просто обнуляют случайные элементы вектора.
Правильно: После обнуления делят на (1 - drop_prob).
Почему важно: Без rescaling среднее значение активаций падает во время обучения, но на inference (где dropout выключен) остаётся нормальным. Это приводит к разному поведению модели в обучении и inference!

❌ Ошибка 7: Не центрируют данные перед PCA/нормализацией
Неправильно: Применяют PCA или batch norm напрямую к данным.
Правильно: Сначала вычитают среднее (центрируют), потом применяют алгоритм.
Почему важно: Многие алгоритмы предполагают, что данные отцентрированы (mean = 0). Без этого результаты искажаются.

❌ Ошибка 8: Думают, что dot product = cosine similarity всегда
Неправильно: “Раз я посчитал dot product, значит я измерил похожесть.”
Правильно: Dot product учитывает и направление, и масштаб. Cosine similarity — только направление.
Почему важно:
- Dot product: [1,1] · [10,10] = 20, [1,1] · [2,2] = 4 — разные, хотя направление одинаковое!
- Cosine similarity: в обоих случаях = 1.0 (идеальная похожесть).
Выбор метрики зависит от задачи!

Главное запомнить

📝 Ключевые понятия

✅ Вектор — упорядоченный список чисел: $\vec{v} = (v_1, v_2, …, v_n)$. В ML — способ представить любой объект числами.

✅ Сложение векторов — покомпонентное: $(a_1, a_2) + (b_1, b_2) = (a_1+b_1, a_2+b_2)$. В ML — комбинирование признаков или embeddings.

✅ Умножение на скаляр — масштабирование: $k \cdot (v_1, v_2) = (k \cdot v_1, k \cdot v_2)$. В ML — контроль силы градиента (learning rate).

✅ Dot product (скалярное произведение) — $\vec{a} \cdot \vec{b} = \sum a_i b_i$. Самая важная операция в ML! Используется везде: нейроны, attention, similarity.

✅ Длина вектора (L2 норма) — $||\vec{v}|| = \sqrt{\sum v_i^2}$. В ML — магнитуда активаций или embedding’а.

✅ Нормализация — деление на длину: $\vec{v}_{norm} = \vec{v} / ||\vec{v}||$. Критична для cosine similarity и стабильности обучения.

✅ Cosine similarity — $\text{cos_sim} = \frac{\vec{a} \cdot \vec{b}}{||\vec{a}|| \cdot ||\vec{b}||}$. Мера похожести от -1 до 1. Основа NLP, рекомендательных систем, поиска.

✅ Embeddings — представление объектов (слов, картинок, пользователей) в виде векторов. Основа современного AI. Похожие объекты → близкие векторы.

✅ Euclidean distance — $d = ||\vec{a} - \vec{b}||$. Альтернатива cosine similarity, учитывает абсолютные расстояния.

✅ Нейрон как dot product — выход нейрона = $\text{activation}(\vec{x} \cdot \vec{w} + b)$. Вся нейросеть — это тысячи таких операций!

Связь с другими темами курса

Что нужно было знать до этого урока: - Базовая арифметика — сложение, умножение, квадратный корень. Векторы — это расширение обычной арифметики на списки чисел. - Координатная плоскость — понимание осей X, Y, Z. Помогает визуализировать векторы как стрелки в пространстве.

Что изучить дальше: - Матрицы и тензоры — обобщение векторов. Матрица = таблица чисел, тензор = многомерный массив. Нейросети работают с тензорами! - Линейные преобразования — как матрицы преобразуют векторы. Каждый слой нейросети = линейное преобразование + нелинейность. - Собственные векторы и PCA — как найти главные направления в данных. Используется для снижения размерности. - Градиентный спуск — оптимизация с использованием векторов градиентов. Основа обучения нейросетей.

Где это нужно в жизни (ML/AI):

💻 В программировании: - NumPy/PyTorch: все операции с массивами — это операции с векторами - Feature engineering: превращение признаков в векторы для моделей - Обработка сигналов: аудио/видео = последовательности векторов

🤖 В ML/AI: - NLP (обработка языка): Word2Vec, BERT, GPT — всё строится на embeddings (векторах слов) - Computer Vision: ResNet, Vision Transformers — картинки превращаются в векторы признаков - Рекомендательные системы: пользователи и товары = векторы, рекомендация = поиск близких векторов - Reinforcement Learning: состояние агента = вектор, действие = выбор на основе векторов

🔬 В Data Science: - Clustering: K-means, DBSCAN — группировка векторов по близости - Dimensionality reduction: PCA, t-SNE — проецирование высокоразмерных векторов в 2D/3D - Anomaly detection: поиск векторов, далёких от основной массы

📊 В исследованиях: - Биоинформатика: ДНК-последовательности → векторы - Финансы: портфели активов = векторы весов - Физика: силы, скорости, ускорения — классические векторные величины

Интересные факты

💡 Исторический факт — Термин “вектор” происходит от латинского “vector” (несущий, переносящий). Его ввёл ирландский математик Уильям Роуэн Гамильтон в 1843 году, изучая кватернионы. Он искал способ описать вращения в 3D пространстве — проблема, которая сейчас критична в компьютерной графике и робототехнике!

💡 Word2Vec магия — В 2013 году Томаш Миколов (Google) показал, что word embeddings обладают удивительным свойством: king - man + woman ≈ queen. Арифметика векторов даёт семантически правильные результаты! Это было прорывом, показавшим, что нейросети могут “понимать” смысл слов.

💡 Высокие размерности не страшны — Интуитивно кажется, что работать с векторами из 768 чисел (BERT) или 12288 чисел (GPT-3) невозможно. Но компьютеры отлично справляются! Более того, в высоких размерностях работают удивительные свойства: почти все случайные векторы почти ортогональны друг другу. Это используется в LSH (locality-sensitive hashing) для быстрого поиска похожих векторов среди миллиардов!

💡 Curse of dimensionality vs Blessing of dimensionality — С одной стороны, в высоких размерностях все точки становятся далеко друг от друга (curse). Но с другой стороны, в высоких размерностях мы можем представить невероятно сложные концепции! GPT-3 с его 12288-мерными embeddings “понимает” нюансы языка, которые невозможно закодировать в 2D или даже 100D.

💡 Attention is all you need — В 2017 статья с этим названием произвела революцию в AI. Авторы показали, что механизм attention (который по сути = умные dot products между векторами) может заменить рекуррентные сети. Так появились Transformers — архитектура, лежащая в основе GPT, BERT, и всех современных LLM. Всё благодаря векторным операциям!

💡 Векторы в биологии — Наш мозг тоже работает с векторами! Нейроны в зрительной коре создают “векторы признаков” для каждого изображения: одни нейроны реагируют на горизонтальные линии, другие на углы, третьи на движение. Это натуральный аналог CNN! Искусственные нейросети вдохновлены именно этим принципом.

Лайфхаки и полезные трюки

1. Быстрая проверка ортогональности
Два вектора ортогональны (независимы), если их dot product = 0.
Пример:

v1 = [1, 2, 3]
v2 = [2, -1, 0]
dot = 1×2 + 2×(-1) + 3×0 = 2 - 2 + 0 = 0  ✓ ортогональны!

Применение: В ML признаки желательно делать ортогональными (декоррелированными), чтобы избежать мультиколлинеарности.

2. Нормализация “на лету” для cosine similarity
Вместо нормализации каждого вектора отдельно, можно сразу вычислять:

cos_sim = (a · b) / (||a|| × ||b||)

Сохраняешь ненормализованные embeddings, а нормализуешь только при сравнении. Экономит память!

3. Dot product через NumPy

import numpy as np
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
dot = np.dot(a, b)  # или просто a @ b

Это в 100+ раз быстрее, чем цикл в Python! NumPy использует оптимизированный C-код.

4. Мнемоника для cosine similarity
“Cosine = Correlation без масштаба”
Если векторы нормализованы (длина = 1), то cosine similarity = correlation coefficient. Это помогает интуитивно понять: мы измеряем, насколько векторы “коррелируют” по направлению.

5. Проверка нормализации: длина должна быть ~1.0
После нормализации всегда проверяй:

assert abs(np.linalg.norm(v_norm) - 1.0) < 1e-6

Из-за ошибок округления может быть не ровно 1.0, но очень близко.

6. Градиент = направление наискорейшего роста
Градиент — это вектор! Он показывает, в каком направлении функция растёт быстрее всего. Поэтому в градиентном спуске мы двигаемся против градиента (чтобы найти минимум).

7. Batch operations всегда быстрее
Вместо цикла по векторам:

# Медленно
for v in vectors:
    result = model(v)

Делай батч:

# Быстро
batch = np.stack(vectors)
results = model(batch)  # одна операция для всех!

GPU любят батчи — параллелят вычисления!

8. Для текста: сумма embeddings ≈ семантика предложения
Простейший способ получить embedding предложения:

sentence_emb = sum(word_embeddings) / len(words)

Не идеально, но работает! BERT делает более умную агрегацию, но для baseline этого хватит.

9. Debugging embeddings: t-SNE visualisation
Если у тебя embeddings в 768D, невозможно понять, хорошие ли они. Используй t-SNE для визуализации в 2D:

from sklearn.manifold import TSNE
embeddings_2d = TSNE(n_components=2).fit_transform(embeddings)
plt.scatter(embeddings_2d[:, 0], embeddings_2d[:, 1])

Похожие объекты должны группироваться!

10. Используй pretrained embeddings
Не обучай word2vec с нуля — скачай готовые! Google предоставил embeddings для 3 миллионов слов (обучены на Google News). Экономия недель вычислений.

💡 Совет: Векторы — это не просто математика, это язык мышления ML-моделей. Чем лучше ты понимаешь векторные операции, тем легче будет понимать, как работают нейросети, attention, transformers и весь современный AI. Практикуйся на реальных данных — возьми Word2Vec embeddings и поиграйся с арифметикой слов, это завораживает!

Что дальше? Переходи к изучению матриц и тензоров — следующий уровень абстракции. Там ты поймёшь, как нейросети обрабатывают батчи данных параллельно, как работают свёртки в CNN, и почему GPU так важны для ML. Удачи! 🚀

Понял тему? Закрепи в боте! 🚀

Попрактикуйся на задачах и получи персональные рекомендации от AI

💪 Начать тренировку
💬 Есть вопрос? Спроси бота!