Программа курса Урок 107 из 250 · Интуиция нейросетей, LLM и ИИ Капстоун
Интуиция нейросетей, LLM и ИИ Капстоун

Self-Attention с нуля

Вы построили нейрон и прямой проход. Теперь вы построите одну идею, которая превратила обычные нейронные сети в transformers и, отсюда, в LLM, стоящие за каждым чат-ассистентом: self-attention. Это всего лишь несколько умножений матриц, и вы можете сделать все это в numpy.

Интуиция

Представьте, что каждое слово в предложении хочет собрать информацию из других слов. Self-attention дает каждой позиции три вектора:

  • query (Q): что ищет эта позиция.
  • key (K): что предлагает каждая позиция, используется для сопоставления.
  • value (V): фактическая информация, которую несет каждая позиция.

A позиция сравнивает свой запрос с каждым ключом, чтобы решить, насколько сильно прислушиваться к каждой другой позиции, а затем берет взвешенную смесь значений с использованием этих весов. Сильное совпадение -> большой вес -> это значение вносит больший вклад. Это и есть весь механизм: запросы обращаются к ключам, а ответ является взвешенной смесью значений.

Математика: масштабированное скалярное внимание

Оценка соответствия между запросом и ключом это их dot product (больше когда они направлены в одну сторону). Сложите все запросы в матрицу Q и все ключи в K, и каждая оценка сразу это Q @ K.T. Мы делим на sqrt(d_k) (размерность ключа) чтобы оценки не раздувались когда векторы становятся длиннее:

scores = Q @ K.T / np.sqrt(d_k)

Зачем вообще делить? Скалярное произведение растет с размерностью. Если d_k равно 64 и значения около 1, сырые оценки оказываются около 64, и такие большие числа толкают softmax на один ключ и сглаживают градиент. Деление на sqrt(d_k), здесь sqrt(64) = 8, возвращает оценки в разумный диапазон, чтобы внимание оставалось плавным и обучаемым. В маленьком примере d_k = 1, который вы запустите ниже, делитель всего лишь 1, поэтому вы не заметите его влияния, но на реальных размерах моделей это необходимо.

Каждая строка в scores содержит оценки одного запроса относительно каждого ключа. Мы превращаем каждую строку в положительные веса с суммой 1 с помощью softmax по последней оси:

weights = softmax(scores, axis=-1)   # each row sums to 1

Softmax возводит в степень и нормализует. Если делать это наивно, np.exp большого значения переполняет inf и веса получаются как nan. Исправление это стандартный трюк numerically stable: вычесть максимум каждой строки перед возведением в степень. Это не меняет результат математически (одна и та же константа сокращается сверху и снизу), но это сохраняет каждый показатель экспоненты <= 0:

def softmax(x):
    x = x - x.max(axis=-1, keepdims=True)   # stability: largest exponent is now 0
    e = np.exp(x)
    return e / e.sum(axis=-1, keepdims=True)

Наконец, выход каждого запроса это его веса, примененные к значениям, что является еще одним умножением матриц:

output = weights @ V

Вместе знаменитая формула превращается в просто softmax(Q @ K.T / sqrt(d_k)) @ V. Если Q это (n, d_k), K это (m, d_k), и V это (m, d_v), тогда weights это (n, m) и output это (n, d_v): один выходной вектор на каждый запрос, каждый из которых является смесью строк значений.

Это весь трюк с трансформером

A настоящий transformer не останавливается на одном вычислении внимания. Многоголовое внимание запускает несколько таких вычислений параллельно (каждая голова учит свои проекции Q, K, V, поэтому разные головы обращают внимание на разные вещи) и объединяет результаты. Transformer block затем объединяет внимание с небольшой feed-forward сетью и residual connection, а модель собирает из десятков таких блоков. Но сердце каждого из них это именно та функция, которую вы сейчас напишете: scores, stable softmax, weighted sum of values. Создайте это и вы поймете основную операцию, которую LLM повторяет, когда она "обращает внимание" на prompt.

Один честный нюанс: здесь Q, K и V передаются вам как фиксированные массивы. В реальной модели они не даны, они производятся путем умножения эмбеддинга каждого токена на три обученные матрицы весов, W_q, W_k и W_v. Эти матрицы, и те, что в каждом блоке, это именно то, что обучение корректирует с помощью градиентного спуска из прошлого урока. Так что то, что вы строите здесь, это фиксированное ядро внимания, которое идентично в каждом трансформере; обучение живет в проекциях, которые питают его.

Нажмите Run, чтобы увидеть, как attention превращает крошечный Q/K/V в выход, и выведите матрицу весов, чтобы вы могли прочитать, кто на кого обратил внимание.

Твоя очередь

Реализуйте scaled dot-product attention в numpy. Напишите attention(Q, K, V), которая возвращает кортеж (output, weights). Вычислите scores = Q @ K.T / np.sqrt(d_k), где d_k это последняя размерность Q; примените numerically stable softmax по последней оси (вычтите максимум каждой строки перед np.exp), чтобы получить weights, строки которого в сумме дают 1; затем output = weights @ V. Сначала верните output, затем матрицу weights. Затем установите out, w = attention(Q, K, V) для предоставленных массивов.

Заметили проблему в этом уроке? Сообщите о ней · Спросить об этом уроке

Это упражнение откроется скоро

Закончи предыдущий урок, чтобы открылся этот. Весь курс бесплатный, аккаунт не нужен, и ты можешь прочитать этот урок прямо сейчас.