Мы живём в эпоху, когда ИИ стал доступен каждому. Но за простотой использования PyTorch скрывается колоссальная инженерная работа и сложные вычислительные процессы, которые для большинства остаются чёрным ящиком.

Это четвёртая статья из цикла «От MNIST к Transformer», цель которого — пошагово пройти путь от простого CUDA-ядра до создания архитектуры Transformer, лежащей в основе современных LLM. Мы не будем использовать готовые высокоуровневые библиотеки. Вместо этого разберём, как всё устроено «под капотом», и пересоберём ключевые механизмы своими руками на низком уровне. Только так можно по-настоящему понять, как работают LLM. В этой статье мы разберём, как работает градиентный спуск, реализуем его и обучим модель на датасете MNIST.

Приготовьтесь: впереди много кода на C++ и CUDA, работа с памятью, погружение в архитектуру GPU и, конечно, математика. Поехали!

О цикле «От MNIST к Transformer»

Это долгий, сложный, но невероятно увлекательный путь. Мы начнём с основ и постепенно будем усложнять задачи. Наша цель — не только понять, как работают современные модели, но и научиться программировать на GPU. Статьи цикла будут выходить постепенно.

1. Самое начало. Разберёмся с основами работы GPU. Напишем первый код на C++ и CUDA для сложения векторов — «hello world» в мире GPGPU.
2. Основы работы с памятью. Изучим устройство памяти GPU. Реализуем ядра для построения гистограммы и транспонирования матрицы — последнее пригодится при создании Transformer.
3. Умножение тензоров. Пишем Linear Layer. Перейдём к тензорам, реализуем умножение и tiled-версию с broadcasting. Создадим полносвязный слой и напишем прямой проход для модели распознавания MNIST.
4. Gradient Descent. Обучаем нашу модель. Наконец-то мы можем обучить модель. В этой статье разберём градиентный спуск — один из ключевых алгоритмов обучения нейросетей. Реализуем его и обучим первую модель распознавания рукописных цифр.

Gradient Descent и Backpropagation

В прошлой статье мы реализовали прямой проход (forward pass): прогнали изображение через слои и получили ответ. На необученной модели этот ответ, скорее всего, случайный. Чтобы модель начала правильно угадывать цифры, нужно изменять веса так, чтобы ошибка (loss) уменьшалась. Для этого используются алгоритмы Gradient Descent (градиентный спуск) и Backpropagation (обратное распространение ошибки).

Представьте, что вы стоите на вершине горы и хотите спуститься в самую глубокую впадину. Вы не видите путь вниз, но чувствуете наклон поверхности. Градиент показывает, в какую сторону функция растёт. Чтобы уменьшить ошибку, нужно двигаться в противоположную сторону — туда, где функция убывает. Поверхность, по которой мы движемся, — это поверхность функции потерь. Цель градиентного спуска — найти её минимум.

Backpropagation — это способ передачи ошибки от выхода сети к входу. Если на выходе модель ошиблась, нужно понять, какой вклад в эту ошибку внес каждый вес. Математически это реализуется через правило цепочки (Chain Rule): мы вычисляем локальную производную в каждом слое и умножаем её на накопленный градиент от последующих слоёв.

Функция ошибки

Для задач классификации, таких как MNIST, стандартной функцией ошибки является кросс-энтропия (Cross-Entropy Loss). Она измеряет, насколько плохо модель предсказывает правильный класс. Например, если на изображении цифра 3, а модель выдаёт 70% вероятности для неё — это хороший результат. Если же уверенность мала — ошибка будет высокой.

Пусть:

• C — количество классов (в MNIST: 10),
• y_i — истинная метка (1 для правильного класса, 0 иначе),
• p_i — предсказанная вероятность (после Softmax).

Тогда кросс-энтропия для одного примера:

Для батча результат усредняется по размеру батча.

Chain Rule: как считать градиенты

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

Архитектура нашей сети:

• Первый линейный слой: z1 = x @ W1 + b1
• ReLU: a1 = ReLU(z1)
• Второй линейный слой: z2 = a1 @ W2 + b2
• Softmax + Loss

Производная ошибки по весам второго слоя вычисляется как:

Рассмотрим сначала градиент по выходу второго слоя z2. Для этого вспомним формулу Softmax:

• z — вектор логитов (вход Softmax),
• p — вектор вероятностей (выход Softmax).

Производная Softmax зависит от того, совпадают ли индексы:

Для i = j: ∂p_i / ∂z_j = p_i (1 - p_i)
Для i ≠ j: ∂p_i / ∂z_j = -p_i p_j

Это можно записать компактно с помощью символа Кронекера δ_ij:

∂p_i / ∂z_j = p_i (δ_ij - p_j)

С учётом кросс-энтропии, градиент ошибки по z2 оказывается очень простым:

∂L / ∂z2 = p - y

Это ключевой результат: градиент на выходе равен разнице между предсказанием и истинной меткой.

Теперь пройдём назад через второй линейный слой. Градиент по весам W2 и смещению b2:

∂L / ∂W2 = a1^T @ (∂L / ∂z2)
∂L / ∂b2 = sum(∂L / ∂z2, axis=0)

Далее — градиент по активации a1, который передаётся через ReLU. Производная ReLU равна 1 при положительных значениях и 0 при отрицательных. То есть:

∂L / ∂z1 = (∂L / ∂a1) * (z1 > 0)

И, наконец, градиенты по W1 и b1:

∂L / ∂W1 = x^T @ (∂L / ∂z1)
∂L / ∂b1 = sum(∂L / ∂z1, axis=0)

Таким образом, мы вычисляем все градиенты, двигаясь от выхода к входу.

Обновление весов: Gradient Descent

После вычисления градиентов наступает финальный шаг — обновление весов. Мы делаем шаг в сторону, противоположную градиенту:

W = W - lr * ∂L / ∂W

где lr — коэффициент скорости обучения (learning rate).

Этот шаг — суть градиентного спуска. В коде он выглядит так:

Для одного слоя обновление включает вычисление градиентов по весам и смещениям, а затем их корректировку.

Обучение сети

Полный цикл обучения:

1. Прямой проход: вычислить выход модели и loss.
2. Обратный проход: вычислить градиенты через backpropagation.
3. Обновить веса с помощью градиентного спуска.

Мы обучаем модель на батчах по 60 изображений в течение 10 эпох. Начальное значение loss — около 2.3, что соответствует случайному угадыванию (вероятность 10%). По мере обучения loss снижается до 0.3–0.4.

• Loss ~ 2.3: случайные предсказания (точность ~10%).
• Loss ~ 1.0: модель начинает понимать данные (точность 50–60%).
• Loss ~ 0.3: хороший результат (точность 90% и выше).

На тестовой выборке мы достигаем точности около 93% — значит, модель научилась распознавать рукописные цифры.

Adam Optimizer

Обычный градиентный спуск — основа, но не предел. В современных моделях чаще используют Adam Optimizer (Adaptive Moment Estimation) — улучшенную версию, которая адаптирует скорость обучения для каждого веса отдельно и учитывает инерцию.

Adam использует два вспомогательных тензора для каждого веса:

• m — первый момент (скользящее среднее градиента),
• v — второй момент (скользящее среднее квадрата градиента).

Они обновляются на каждом шаге:

m = β₁·m + (1 - β₁)·g
v = β₂·v + (1 - β₂)·g²

где g — текущий градиент, β₁ ≈ 0.9, β₂ ≈ 0.999.

Веса обновляются так:

W = W - lr · m / (√v + ε)

где ε — малое число (например, 1e-8), чтобы избежать деления на ноль.

Хотя мы не реализуем Adam в этой статье, важно понимать, что именно он используется в современных LLM вместо простого SGD.

Заключение

Мы разобрали один из ключевых механизмов обучения нейросетей — градиентный спуск и обратное распространение ошибки. Полноценно обучили двухслойную полносвязную сеть на MNIST и достигли точности 93%. Самое главное — заложили фундамент для построения Transformer.

В следующих статьях мы начнём собирать Transformer по блокам — от внимания до полной архитектуры, лежащей в основе всех современных LLM.

Надеюсь, было понятно и, главное, интересно. Продолжение следует…

Мы живем в эпоху, когда ИИ стал доступен каждому. Но за магиейPyTorchскрывается колоссальная инженерная работа и сложные вычислительные процессы, которые для большинства остаются черным ящиком.

Это четвертая статья из циклаОт MNIST к Transformer, цель которого пошагово пройти путь от простого CUDA ядра до создания архитектуры Transformer - фундамента современных LLM моделей. Мы не будем использовать готовые высокоуровневые библиотеки. Мы будем разбирать, как все устроено под капотом, и пересобирать их ключевые механизмы своими руками на самом низком уровне. Только так можно по настоящему понять как работают LLM и что за этим стоит. В этой статье мы разберем как работает градиентный спуск, реализуем его и обучим нашу модель для распознования mnist датасета.

Приготовьтесь, будет много кода на C++ и CUDA, работы с памятью и погружения в архитектуру GPU. И конечно же математика что за этим стоит. Поехали!

О цикле "От MNIST к Transformer"

Это будет долгий, сложный, но невероятно увлекательный путь. Мы начнем с самых азов и будем шаг за шагом усложнять задачу. Наша цель не только досконально понять как работают современные модели, но и научится программировать на GPU. Статьи для цикла будут выходить постепенно.

1. Самое начало.Разберемся с основами работы GPU. Напишем наш первый код наC++иCUDAдля простейшей операции сложения векторов, hello world в мире GPGPU и CUDA, чтобы понять, как CPU и видеокарта общаются друг с другом.Статья вот тут.
2. Основы работы с памятью.Разберемся с основами работы и устройства памяти в GPU. Напишем четыре ядра для двух операций (простой подход и оптимизированный), построение гистрограммы для вектора и транспонирование матрицы. Операция транспонирования нам понадобится в будущем что бы собирать наш Transformer.Статья вот тут.
3. Умножение тензоров. Пишем Linear Layer.Перейдем от матриц к тензорам, напишем умножение простое умножение тензоров и потом сделаем tiled вариант c broadcasting. Создадим полносвязный слой нейронной сети и напишем прямой проход для нашей модели которая будет распозновать mnist дата сет. Так же не забываем про CUDA: немного углубимся в способы синхронизации CPU и GPU, в реализации mnist модели мы их использовать не будем для простоты, но они пригодятся в дальнейшем.Статья вот тут.
4. Gradient Descent. Обучаем нашу модель. (Мы здесь)Наконец-то мы можем обучить нашу модель из прошлой статьи. В этой статье разберем как работает градиентный спуск, один из основных алгоритмов обучения нейросетей. Реализуем его на практике и обучим нашу первую модель расопзнованию рукописных чисел.

Gradient Discent и Backpropagation

В прошлой статье мы написали Forward Pass - прогнали картинку через слои и получили какой-то ответ. Скорее всего, на нетренированной модели этот ответ будет случайным. Чтобы модель начала угадывать цифры, нам нужно менять веса так, чтобы ошибка (Loss) становилась меньше. Для того что бы это сделать существует такие алгоритмы какGradient Discent(градиентный спуск)иBackpropagation(обратное распространение ошибки).

Что же такое градиентный спуск общими словами. Давайте представим, что мы стоим на вершине горы (global maximum), и нам нужно спуститься в самую глубокую яму (global minimum). Но мы не видим где же находится эта ямы мы только можем понимать наклон поверхности. Для того что бы вычислить наклон нам как раз и нужен градиент. Он просто показывает, в какую сторону поверхность идет вверх. А раз нам нужно вниз, мы идем в противоположную сторону. А вся поверхность на которой мы стоим (и гора и яма) это поверхность функции ошибки. То есть глобальная задача такого алгоритма это найти минимум функции ошибки.

Backpropagation(обратное распространение ошибки) - это процесс как бы передачи ошибки от выхода сети к её входу. Если на этапе Forward мы получили ошибку, нам нужно понять, как каждый конкретный вес на неё повлиял. Математически это реализуется черезправило цепочки (Chain Rule): мы вычисляем локальную производную текущего слоя и умножаем её на накопленный градиент, пришедший от слоев, стоящих ближе к выходу.

Функция ошибки

Кросс-энтропия (Cross-Entropy Loss) - это стандартный способ измерить, насколько «плохо» наша модель предсказывает классы. В случае с MNIST это способ понять, насколько сильно нейросеть ошиблась, назвав рукописную «пятерку» «тройкой».

Представим, что на выходе нейросети после слоя Softmax у нас есть вероятности. Например, для картинки с цифрой3модель выдала: Цифра 2:10%, Цифра 3:70%(правильный ответ) и тд.

Формула Кросс-энтропии для одного примера представлена ниже:

• - количество классов (в случае MNIST это 10).
• ​ - истинное значение (1 для правильного класса, 0 для остальных).
• - предсказание модели (вероятность из Softmax).

Так как часто мы на вход для обучения мы даем не один пример, а целую пачку или batch, то для батча мы должны поделить значение на размера батча (- batch size):

Код для вычисления кросс-энтропии, опять же будем считать на CPU для упрощения:

Chain rule

Так мы определились с функцией ошибки и для того что бы найти минимум функции нам нужно найти наклон функции в точке в которой мы находимся для этого нам нужно найти градиент функции ошибки по отношению к весам сети.

Для того что бы найти градиент нам нужно взять производную от функции ошибки по весам. В данной статье я не буду подробно рассматривать что такое производная функции. Если совсем просто, производная - это скорость изменения чего-либо (функции в нашем случае). Для того что бы найти производную от функции ошибкипо отношению кдавайте вспомним архитекутру сети из прошлой статьи:

• Первый слой:
• Активация (ReLU):
• Второй слой:
• Выход (Softmax + Loss):

Исходя из архитектуры сети производную от функции ошибкипо отношению кможно найти по правилу цепочки(Chain rule)

Для начала давайте рассмотрим первую часть производной, для этого так же вспомним как выглядит функция softmax, для каждого элементав векторе​:

• ​: выход второго линейного слоя (вектор логитов).
• ​: результат Softmax (вектор вероятностей).

Давайте по очереди возьмем производные, сначала возьмем первую частьпо:

Теперь давайте возьмем производную второй части, а именно Softmax по, тут чуть сложнее. Для того чтобы найти производную Softmax, нам понадобится правило производной частного:

Формула softmax:

Упростим, разбив на две дроби

Рассмотрим так же случай когда(внедиагональные элементы):

Итого для второго случая:

Чтобы не писать два случая, математики используют символ Кронекера​ (он равен 1, если, и 0 в остальных случаях):

Давайте теперь обьеденим Softmax поипо:

Так как сумма всех(истинных вероятностей) всегда равна 1, получаем финальную, максимально простую формулу:

Вот так это считается в коде:

Все это было только для градиентов результата (Softmax + Loss), давайте пойдем дальше но дальше будет чуть легче. Теперь мы подходим к моменту, когда ошибку нужно пробросить от выхода второго слоя (​) назад ко входу (), который прошел через активацию ReLU.

Далее берем

И последний шагпо аналогии

Итого давайте соединим все вместе:

Теперь давайте для каждого линейного слоя напишем код для вычисления градиента при обратном прохождении.

Давайте еще немного разберем вот эту строчку кода

Для этого вспомним формулу для одного нейрона:Чему равна производнаяпо? Правильно онаравна 1. Итого мы имеем:

Или для одних входных данных градиент по смещению - это и есть сам градиент ошибки на этом слое. Ядро CUDA для вычисленияsum_rows_inplaceвыглядит так:

Gradient Discent

Давайте еще посмотрим на эти две строчки ниже в функции обратного подхода для одного слоя.

Эти строчки по сути финал всей работы алгоритма градиентного спуска. Когда мы вычислили градиенты (нашли направление, куда нужно двигаться), нам нужнообновить веса. learning_rate) — коэффициент скорости обучения. Общая форму GCD выглядит так:

Давайте теперь посмотрим на код обратного прохода для всей сети.

И один этап обучения выглядит таким образом, сначала делаем прямой проход, считаем loss потом делаем обратный проход и обновляем веса.

Обучение сети

После того как мы разобрались с градиентами сети обратным и прямым проходом при обучении сети, давайте теперь напишем код для всего обучения.

Для обучения мы возьмем батч размером в 60 изображений и пройдем 10 эпох обучения. В начале обучения Loss у нас будет принимать значение около 2.3 что объясняется тем что в начала обучения модель просто угадывает число с вероятностью 10% или 0.1 если мы подставим это число в функцию ошибки то как раз получим примерно 2.3. В конце обучения значение loss опустится до значений примерно 0.3 - 0.4.

• Loss ~ 2.3:Рандомное угадывание (10% точности).
• Loss ~ 1.0:Модель начала что-то понимать, точность около 50–60%.
• ~0.3:Хороший результат для простой полносвязной сети (90%+ точности).

Если мы потом возьмем примеры из тестовой выборки и проверим Accuracy то получим примерно 93%. Что может означать что наша модель научилась распознавать числа и MNIST датасета.

Adam Optimizer

Еще пару слов стоит сказать про другие оптимизаторы. Ранее мы рассмотрели просто Gradient Discent и это просто шаг в сторону спуска,AdamOptimizer(Adaptive Moment Estimation) - это улучшенная версия обычного градиентного спуска, который учитывает инерцию и подстраивает скорость для каждого веса отдельно. Современные LLM и Трансформеры почти никогда не обучаются на обычном SGD. В данной статье мы рассмотрели обычный оптимизатор для понимания основ. Давайте немного опишем теорию Adam оптимизатора.

Нам понадобятся две дополнительные переменные для каждого веса (еще два вспомогательных тензора такого же размера, как веса слоя):

• ​ (первый момент) — среднее значение градиента (инерция).
• ​ (второй момент) — среднее значение квадрата градиента (адаптивность).

Эти два тензора так же обновляются в процессе обучения.

Где​ - это текущий градиент, а​ (обычно 0.9) и​ (обычно 0.999) - коэффициенты затухания.

Обновление же весов сети происходит по формуле:

Где- крошечное число (например), чтобы не делить на ноль.

На этом пока остановимся и не будем реализовывать Adam Optimizer в текущей статье. В целом доработки к обычному оптимизатору не сложные.

Заключение

На этом пока все. Мы разобрали очень важную тему, а именно как работает алгоритм обучения нашей нейронной сети. Так же полноценно обучили нашу полносвязную двухслойную нейронную сеть. И cамое главное заложили большой фундамент к построению трансформера. В следующих статьях мы начнем уже по блокам строить наш трансформер что является основой всех современных LLM.

Надеюсь было понятно и самое главное интересно. Продолжение следует ...

Подробный код для статьи можно посмотреть наgithub. Так же если хотите следить и данная тема вам интересна можете подписаться наканал в телеграммесозданный специально для этого цикла статей, там будут анонсы статьей по циклу, обсуждения, ваши запросы и многое другое.