Инженер машинного обучения: от математического вывода до проектирования архитектур

Если передать цветное изображение размером 256×256 пикселей в алгоритм машинного обучения, компьютер не увидит ни форм, ни текстур. Он зафиксирует единственную точку в пространстве, имеющем 196 608 измерений. Вся работа инженера машинного обучения — от проектирования архитектур до тонкой отладки весов — сводится к навигации в таких многомерных пространствах. Когда при обучении кастомной архитектуры функция потерь выдает NaN (Not a Number), готовые API и подсказки LLM-ассистентов оказываются бессильны. В этот момент инженер должен спуститься на уровень математики: проверить обусловленность матриц, вычислить аналитический градиент и найти слой, в котором происходит арифметическое переполнение. Линейная алгебра предоставляет инструменты для хранения данных и трансформации пространства, а математический анализ дает компас, показывающий, как нужно изменить параметры трансформации для минимизации ошибки.

Линейная алгебра: язык представления данных

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

От скаляра к тензору и физической памяти

Скаляр — это одиночное число. В ML скалярами обычно выступают гиперпараметры (например, скорость обучения) или итоговое значение функции потерь.

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

Здесь — вектор, — множество действительных чисел, а — размерность пространства (количество элементов в векторе). Любой объект в ML (пользователь, текст, пиксель) в конечном итоге кодируется вектором признаков (feature vector).

Матрица — это двумерный массив чисел. Если вектор — это один объект, то матрица часто представляет собой набор объектов (датасет), где строки — это отдельные примеры, а столбцы — их признаки. Также матрицы хранят веса нейронных сетей. Матрица размерности содержит строк и столбцов.

Тензор — это обобщение матриц на три и более измерений.

!Визуализация структуры четырехмерного тензора данных с измерениями: пакет, каналы, высота и ширина.

Батч (пакет) из 32 цветных изображений размером 256×256 пикселей представляется в памяти как тензор размерности . Первое измерение — размер батча, второе — три цветовых канала (Red, Green, Blue), третье и четвертое — высота и ширина в пикселях.

Для инженера, пишущего собственные слои на C++ или CUDA, абстракции размерностей недостаточно. Важно понимать, как тензор развернут в одномерный массив физической оперативной памяти (RAM или VRAM). В глубоком обучении существуют два основных стандарта компоновки памяти для изображений: NCHW (канализация в начале) и NHWC (канализация в конце), где N — батч, C — каналы, H — высота, W — ширина. Если библиотека cuDNN ожидает данные в формате NHWC для ускоренной тензорной свертки, а вы передаете NCHW, код может выполниться без ошибок, но работать в 10 раз медленнее из-за постоянных промахов кэша при чтении неоптимально расположенных байтов.

Скалярное произведение (Dot Product) и аппаратное ускорение

Скалярное произведение двух векторов — это базовая операция, на которой строится оценка сходства объектов и работа искусственных нейронов. Алгебраически это сумма попарных произведений элементов двух векторов:

Где и — векторы одинаковой размерности , — транспонированный вектор (превращенный из столбца в строку), и — соответствующие элементы векторов. Результатом этой операции является скаляр.

Геометрический смысл скалярного произведения раскрывается через косинус угла между векторами:

Где и — длины (нормы) векторов, а — угол между ними в -мерном пространстве.

Если векторы нормализованы (их длины равны 1), скалярное произведение в точности равно косинусу угла между ними. Это свойство лежит в основе косинусного сходства (cosine similarity). В высоконагруженных рекомендательных системах предварительная L2-нормализация векторов позволяет заменить сложную операцию вычисления косинуса на простое скалярное произведение. Современные процессоры и видеокарты имеют специализированные инструкции (например, FMA — Fused Multiply-Add), которые выполняют умножение и прибавление к сумме за один такт процессора, что делает скалярное произведение самой быстрой операцией в ML.

Умножение матриц как линейное преобразование и информационное «бутылочное горлышко»

Математически умножение вектора на матрицу — это процесс трансформации пространства. Применяя матрицу к вектору, мы осуществляем линейное преобразование (поворот, растяжение, сжатие или отражение).

Где — исходный вектор размерности , — матрица весов размерности , а — новый вектор размерности .

Каждый столбец матрицы показывает, где окажутся базисные векторы исходного пространства после преобразования. Если исходный вектор находился в трехмерном пространстве (), а матрица имеет размер 128×3, то умножение перенесет данные из 3-мерного пространства в 128-мерное.

!Интерактивная визуализация линейного преобразования плоскости: 4 слайдера задают матрицу 2×2, координатная сетка и базисные векторы плавно деформируются в реальном времени, показывая геометрический смысл умножения матрицы на вектор.

При проектировании архитектур инженер должен учитывать ранг матрицы и размерности скрытых слоев. Если мы проецируем вектор размерности 1024 в пространство размерности 64 (умножая на матрицу ), а затем пытаемся восстановить обратно в 1024, мы создаем информационное «бутылочное горлышко» (bottleneck). Математика гарантирует, что мы не сможем восстановить исходные данные без потерь, так как ранг результирующей трансформации не превышает 64. Этот принцип лежит в основе работы автоэнкодеров: заставляя сеть сжимать данные через матрицу меньшей размерности, мы принуждаем ее выделять только самые важные, фундаментальные признаки объектов.

Собственные векторы и число обусловленности

При умножении вектора на матрицу он обычно меняет длину и направление. Для квадратной матрицы существуют векторы, которые при умножении на нее только растягиваются или сжимаются, не меняя направления. Это собственные векторы (eigenvectors), а коэффициент их растяжения — собственное значение (eigenvalue).

Где — квадратная матрица, — собственный вектор (ненулевой), — собственное значение (скаляр).

Для ML-инженера анализ собственных значений — это инструмент отладки стабильности обучения. Отношение наибольшего по модулю собственного значения к наименьшему называется числом обусловленности матрицы (condition number). Если это число огромно (например, ), матрица считается плохо обусловленной. В контексте машинного обучения это означает, что функция потерь в одних направлениях пространства весов будет невероятно крутой, а в других — почти плоской. Градиентный спуск в такой ситуации начнет осциллировать (метаться из стороны в сторону), и обучение остановится. Понимание этого механизма заставляет инженеров применять методы нормализации батчей (Batch Normalization) или слоев (Layer Normalization), которые математически улучшают обусловленность матриц ковариации признаков.

Математический анализ: механика обучения и отладки

Линейная алгебра описывает структуру данных и прямой проход (forward pass). Математический анализ отвечает за обратный проход (backward pass) — поиск таких значений весов, при которых функция потерь достигает минимума.

Градиент и проблема седловых точек

Производная функции одной переменной показывает мгновенную скорость изменения функции в конкретной точке. В моделях с миллионами параметров используется вектор частных производных — градиент.

Где — градиент функции потерь в точке , а — частная производная по -му параметру.

Градиент указывает направление наискорейшего возрастания функции. Алгоритмы оптимизации делают шаг в направлении антиградиента.

!Интерактивная 3D-визуализация поверхности функции потерь (параболоид): точка на поверхности показывает текущие веса, красный вектор — направление градиента (вверх по склону), синий — антиградиент (к минимуму). Управление: вращение мышью, слайдеры X и Y для перемещения точки.

При глубоком аудите кода инженер обязан уметь выполнять проверку градиента (gradient checking). Баги в реализации слоев часто не вызывают ошибок выполнения, но приводят к неверным вычислениям производных. Аналитический градиент (вычисленный по формулам) сверяется с численным градиентом, который вычисляется по определению производной:

Где — очень малое число (например, ). Если разница между аналитическим и численным градиентом превышает заданный порог, в коде обратного прохода есть ошибка.

Также в многомерных пространствах (от измерений и выше) градиент часто равен нулю не в точках минимума, а в седловых точках (saddle points). В этих точках функция возрастает по одним измерениям и убывает по другим. Математический анализ показывает, что вероятность встретить локальный минимум в пространстве с миллионом измерений экспоненциально мала по сравнению с вероятностью встретить седловую точку. Именно поэтому современные оптимизаторы (Adam, RMSprop) используют инерцию (momentum), чтобы алгоритм «проскакивал» плоские участки седловых точек, не останавливаясь в них.

Матрицы Якоби и Гессе: пределы вычислений

Когда функция возвращает вектор, градиент обобщается до матрицы Якоби (Якобиана), содержащей частные производные каждого выхода по каждому входу.

Где — элемент матрицы Якоби, — -й элемент выходного вектора, — -й элемент входного вектора.

Матрица вторых производных — матрица Гессе (Гессиан) — описывает кривизну поверхности функции потерь.

Где — смешанная вторая частная производная.

В теории оптимизации использование Гессиана (метод Ньютона) позволяет достичь минимума за несколько шагов, так как алгоритм учитывает кривизну пространства. Но на практике для сети с параметров Гессиан будет иметь размер , требуя терабайты оперативной памяти только для хранения одной матрицы. Поэтому инженеры используют методы первого порядка (основанные только на градиенте) или квазиньютоновские алгоритмы (L-BFGS), которые аппроксимируют обратный Гессиан, не вычисляя его напрямую.

Цепное правило и затухание градиентов

Нейронная сеть — это цепочка вложенных математических функций: . Цепное правило (Chain Rule) позволяет найти производную сложной функции.

Для функций и :

Где — итоговый градиент, вычисленный как произведение локального градиента и градиента предыдущего шага .

Цепное правило обнажает главную проблему глубоких сетей — затухание градиента (vanishing gradient). Если в качестве функции активации используется сигмоида, ее максимальная производная равна . В сети из 10 слоев градиент для первого слоя будет включать умножение десяти таких производных. . Сигнал об ошибке математически уничтожается, и первые слои перестают обучаться. Понимание этого факта привело инженеров к созданию функции активации ReLU (где производная равна 1 для положительных чисел) и архитектуры ResNet (где добавление исходного вектора к выходу слоя создает параллельный путь с градиентом, равным 1).

Синтез: математика в строке кода и «мертвые нейроны»

Рассмотрим базовую операцию ML-алгоритма с точки зрения инженера, отлаживающего сеть: линейную комбинацию признаков с последующей нелинейной активацией.

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

Где — линейный выход (скаляр), — транспонированный вектор весов, — смещение.

Далее применяется функция активации ReLU, чтобы сеть могла моделировать нелинейные зависимости:

Где — итоговое предсказание.

Вычисляем квадратичную ошибку:

Где — функция потерь, — реальная цена.

Для обновления весов вычисляем градиент по цепному правилу:

Вычисляем компоненты:

Ошибка:

Активация: , если , и , если .

Линейный слой:

Перемножаем их:

Где — индикаторная функция (равна 1 при выполнении условия, иначе 0).

Здесь математика показывает классический баг архитектуры — «мертвый ReLU» (dying ReLU). Если при инициализации весов или из-за слишком большого шага обучения (learning rate) значение становится отрицательным для всех примеров в батче, то производная нелинейности становится строго равной нулю. Из-за цепного правила весь итоговый градиент обнуляется. Веса перестают обновляться навсегда. Инженер, понимающий этот математический вывод, не будет слепо менять гиперпараметры, а осознанно заменит ReLU на Leaky ReLU (где производная при отрицательных значениях равна, например, ) или снизит скорость обучения.

Рекомендуемые ресурсы для углубленного изучения

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

Книги и учебники:

«Deep Learning» (Ian Goodfellow, Yoshua Bengio, Aaron Courville). Фундаментальный труд. Главы 2 (Linear Algebra) и 4 (Numerical Computation) обязательны для понимания вычислительной стабильности.

«Mathematics for Machine Learning» (Marc Peter Deisenroth, A. Aldo Faisal, Cheng Soon Ong). Отличный мост между абстрактной университетской математикой и ее применением в ML. Доступна легально в PDF на английском языке.

«Глубокое обучение. Погружение в мир нейронных сетей» (С. Николенко, А. Кадурин, Е. Архангельская). Качественное русскоязычное издание с подробным разбором математики обратного распространения ошибки.

Статьи и блоги:

Блог Криса Ола (colah.github.io). Эталонные визуализации линейных преобразований, работы матриц в нейронных сетях и топологии данных.

Distill.pub. Журнал с интерактивными статьями, детально разбирающими математику оптимизации и визуализацию градиентов (например, статья «Why Momentum Really Works»).

Видеокурсы и YouTube-каналы (на русском языке):

Лекции Школы анализа данных (ШАД) Яндекса. На YouTube доступны записи курсов по машинному обучению (лектор Константин Воронцов) — золотой стандарт строгого математического вывода алгоритмов в рунете.

Курсы Open Data Science (ODS) / Тренировки по ML. Разбор практических нюансов, включая работу с тензорами и оптимизацию памяти.

Лекции Бориса Борисова (МФТИ). Глубокий разбор линейной алгебры и тензорного исчисления с прицелом на компьютерное зрение и глубокое обучение.

Кандидат блестяще выводит математику механизма внимания на доске, пишет безошибочный код на PyTorch для обучения Трансформера, но получает отказ на позицию Senior ML Engineer. Причина выясняется на этапе System Design: когда интервьюер просит спроектировать систему рекомендаций видео, кандидат сразу начинает описывать архитектуру нейросети, проигнорировав вопросы о том, как система будет обрабатывать 100 000 запросов в секунду, откуда возьмутся данные в реальном времени и как бизнес поймет, что модель вообще приносит деньги. В реальной индустрии код самой модели — это лишь 5-10% системы. Остальные 90% — это распределенная инфраструктура данных, обеспечение жестких ограничений по времени ответа, сетевые протоколы и непрерывный мониторинг деградации в продакшене.

Фреймворк системного проектирования

Интервью по ML System Design кардинально отличается от алгоритмических секций (LeetCode) или проверки знания архитектур. Здесь нет единственно верного ответа, а проверяется способность мыслить масштабно, структурированно и переводить абстрактные бизнес-требования в конкретные инженерные узлы. Успешное проектирование требует строгого следования фреймворку, нарушение порядка в котором ведет к созданию системы, решающей не ту задачу.

Первый шаг — формулирование задачи (Problem Formulation) и сбор требований. Когда звучит задача «спроектируйте систему обнаружения мошенничества (фрода)», инженер не должен думать об алгоритмах. Он должен задать граничные условия. Является ли система синхронной (блокирует транзакцию до ее завершения) или асинхронной (анализирует постфактум и замораживает аккаунт)? Каков допустимый бюджет времени на ответ? Если транзакция должна быть одобрена за 50 миллисекунд, использование тяжелых ансамблей градиентного бустинга над тысячами признаков отпадает на архитектурном уровне — система физически не успеет собрать данные и выполнить инференс.

Второй шаг — иерархия метрик. Необходимо выстроить мост между математикой и деньгами, разделив бизнес-метрики, offline-метрики и online-метрики. * Бизнес-метрика отражает финансовую эффективность или глобальную вовлеченность (например, снижение финансовых потерь от фрода на 15% или рост LTV пользователя). * Offline-метрика используется дата-саентистами при обучении модели на исторических данных (ROC-AUC, Precision-Recall AUC, NDCG). * Online-метрика замеряется в A/B-тестах на живом трафике (Click-Through Rate, среднее время сессии).

Разрыв между offline и online метриками — классическая проблема. Модель рекомендаций может показывать идеальный метрику ранжирования NDCG на исторических данных, но провалиться в A/B-тесте. Причина кроется в законе Гудхарта: если модель научится идеально предсказывать клики (CTR), она начнет рекомендовать исключительно кликбейт. Пользователи будут чаще кликать, но быстрее разочаровываться и закрывать приложение, что приведет к падению online-метрики «время сессии» и бизнес-метрики «доход от рекламы».

Инженерия признаков и Point-in-Time Correctness

Третий шаг проектирования касается потоков данных. В масштабируемых ML-системах признаки (features) вычисляются не скриптами в Jupyter Notebook перед инференсом, а хранятся в специализированных инфраструктурных узлах — Feature Stores (хранилищах признаков).

Feature Store имеет двойную природу. Для обучения моделей (offline) он работает поверх колоночных баз данных или распределенных файловых систем (например, Apache Parquet в S3), обеспечивая высокую пропускную способность при выгрузке терабайтов данных. Для продакшена (online) он использует in-memory базы данных (например, Redis), обеспечивая чтение векторов признаков за единицы миллисекунд. Главная задача Feature Store — гарантировать, что модель получает абсолютно идентичные скрипты расчета признаков как при обучении, так и в реальном времени (устранение training-serving skew).

Самая коварная ошибка на стыке инженерии данных и машинного обучения, которую проверяют на интервью — нарушение Point-in-Time Correctness (корректности на момент времени). Это специфическая форма утечки данных (Data Leakage), возникающая при объединении (join) таблиц с временными рядами.

Предположим, мы обучаем модель предсказания дефолта по кредиту. Историческая транзакция-заявка произошла 15 марта в 14:00. В качестве признака мы хотим использовать агрегацию «средний баланс счета клиента за последние 30 дней». Если при формировании обучающей выборки в мае дата-инженер просто присоединит текущее значение баланса из базы данных (на момент выгрузки данных), произойдет заглядывание в будущее.

Модель может обнаружить, что нулевой баланс идеально предсказывает дефолт. Но в реальности баланс стал нулевым потому что клиент допустил дефолт в марте, и банк принудительно списал средства в апреле. Модель выучит паттерн, которого физически не существовало в момент принятия решения 15 марта.

!Интерактивный таймлайн Point-in-Time Correctness: переключение между наивным джоином (утечка данных — все события до мая) и корректным Point-in-Time джоином (только события строго до 15 марта).

Чтобы соблюсти Point-in-Time Correctness, Feature Store должен поддерживать запросы вида «вычисли значение признака X для пользователя Y, используя только те события, чья временная метка строго меньше ». Это требует хранения иммутабельной истории всех изменений (event sourcing) и выполнения вычислительно сложных AS OF джоинов.

Двухэтапная архитектура: Retrieval и Ranking

Четвертый шаг — выбор архитектуры модели. Когда речь идет о системах с огромным пространством ответов (рекомендации товаров, поиск по документам, подбор музыки), невозможно прогнать сложную нейросеть через все доступные объекты за отведенные 100 миллисекунд. Стандартом индустрии является двухэтапная воронка (Two-Stage Pipeline).

!Двухуровневая архитектура рекомендательной системы: быстрый отбор кандидатов и их точное ранжирование.

Первый этап — Генерация кандидатов (Retrieval). Задача этого слоя — максимально быстро сузить пространство поиска с десятков миллионов объектов до нескольких сотен. Здесь критически важна метрика Recall (полнота) — система не должна потерять действительно релевантный объект на самом старте. Вычислительная сложность на один объект должна быть минимальной.

Чаще всего для Retrieval используется архитектура Two-Tower (двухбашенная нейросеть). Одна подсеть кодирует исторический контекст пользователя в плотный вектор , другая кодирует контент объекта (например, текст и метаданные видео) в вектор . Релевантность вычисляется как косинусное сходство между ними:

В этой формуле — вектор-эмбеддинг пользователя, — вектор-эмбеддинг объекта, — их скалярное произведение, а знаменатель отвечает за нормализацию длин векторов.

Математическая элегантность Two-Tower архитектуры заключается в строгой изоляции башен. Векторы для всех 100 миллионов видео можно вычислить заранее (offline) и положить в индекс векторной базы данных. При запросе пользователя в реальном времени система пропускает через нейросеть только признаки пользователя, получая вектор . Далее выполняется алгоритм приближенного поиска ближайших соседей (Approximate Nearest Neighbors, ANN).

Вместо того чтобы честно умножать вектор на 100 миллионов векторов (что заняло бы секунды), алгоритмы вроде HNSW (Hierarchical Navigable Small World) строят многослойный граф, где поиск спускается от длинных связей к коротким, находя топ-1000 кандидатов за 2-3 миллисекунды логарифмического времени.

Второй этап — Ранжирование (Ranking). Теперь база сужена до 1000 кандидатов. Задача ранжирующей модели — отсортировать их с максимальной точностью (Precision). Поскольку объектов мало, мы можем использовать вычислительно тяжелые модели. Здесь применяются алгоритмы градиентного бустинга (XGBoost, LightGBM) или тяжелые DLRM (Deep Learning Recommendation Models) с механизмом Cross-Attention. В отличие от Two-Tower, здесь признаки пользователя и объекта объединяются (конкатенируются или перемножаются) на самых ранних слоях нейросети, что позволяет улавливать сложные нелинейные зависимости (например, «пользователям из Москвы старше 30 лет нравится этот конкретный жанр по пятницам»).

Сетевые протоколы и сериализация данных

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

Использование классического REST API с форматом JSON — антипаттерн для высоконагруженных ML-систем. JSON передает данные в виде текста. Если модель принимает на вход массив из 1000 чисел с плавающей точкой (float32), каждое число будет переведено в строку символов. Число 3.1415926 займет 9 байт вместо 4 байт в бинарном виде, а парсинг текста на стороне сервера потребует значительных ресурсов CPU.

Вместо этого в ML System Design стандартом является использование протокола gRPC с сериализацией Protocol Buffers (Protobuf). Protobuf упаковывает тензоры в плотный бинарный формат, сохраняя типы данных (float32, int64), а gRPC использует постоянные соединения поверх HTTP/2, устраняя накладные расходы на установку TCP-соединения для каждого запроса. Переход с REST на gRPC часто снижает задержку сетевого слоя в 3-5 раз.

Развертывание (Serving) и оптимизация инференса

Пятый шаг — дизайн самого инференса на аппаратном уровне. Необходимо оперировать двумя фундаментальными метриками производительности: Latency (задержка) и Throughput (пропускная способность).

* Latency измеряется в миллисекундах и показывает, сколько времени проходит от отправки одного запроса до получения ответа. * Throughput измеряется в запросах в секунду (RPS или QPS) и показывает общий объем работы, который сервер может выполнить за единицу времени.

Инженерный компромисс при работе с нейросетями заключается в механизме динамического батчинга (Dynamic Batching). Видеокарты (GPU) обладают колоссальной вычислительной мощностью, но крайне неэффективны при обработке запросов по одному (batch size = 1).

Архитектура GPU создана для параллельного умножения огромных матриц. При размере батча, равном единице, система упирается в пропускную способность памяти (Memory Bandwidth Bound): время тратится на загрузку весов модели из видеопамяти в вычислительные ядра (Tensor Cores), а сами вычисления происходят мгновенно, оставляя ядра простаивающими. Если сервер будет отправлять каждый входящий запрос на GPU немедленно, Latency будет минимальной (скажем, 15 мс), но Throughput окажется ничтожно малым — сервер захлебнется уже при 50 RPS.

!Интерактивный график компромисса Latency vs Throughput: слайдер размера батча показывает, как растёт задержка и взлетает пропускная способность GPU, выходя на плато при больших батчах.

Динамический батчинг работает иначе: сервер намеренно задерживает первый пришедший запрос на несколько миллисекунд в специальной очереди, ожидая поступления других запросов. Как только накапливается оптимальный размер батча (например, 32) или истекает жесткий таймаут ожидания (например, 10 мс), весь батч отправляется на GPU единой матрицей.

При батче размера , входной тензор размерности умножается на матрицу весов. Веса загружаются из памяти ровно один раз и применяются сразу к 32 запросам. Процесс становится ограниченным вычислениями (Compute Bound), что является оптимальным режимом работы GPU. Это слегка увеличивает Latency для индивидуального пользователя (например, до 25 мс), но увеличивает Throughput системы в десятки раз (до 1500 RPS), экономя бизнесу сотни тысяч долларов на аренде оборудования.

Мониторинг и математика деградации распределений

ML-система начинает устаревать в ту же секунду, как попадает в продакшен. На интервью обязательно проверяется знание механизмов мониторинга. Падения баз данных вызывают громкие алерты, но деградация ML-модели происходит бесшумно — сервис продолжает возвращать HTTP 200 OK, но предсказания становятся мусором.

Различают два типа деградации:

Data Drift (смещение данных) — изменение статистического распределения входных признаков. Например, макроэкономическая инфляция изменила средний чек пользователей, и модель, обученная на старых ценах, начинает занижать скоринг платежеспособности.

Concept Drift (смещение концепции) — изменение фундаментальной связи между признаками и целевой переменной. Например, в период пандемии покупка авиабилетов перестала быть индикатором высокого дохода и готовности к путешествиям, превратившись в маркер экстренной релокации.

Для автоматического обнаружения Data Drift инженеры используют математические метрики расхождения распределений. Одной из самых надежных в банковской и ML-индустрии является Population Stability Index (PSI).

PSI сравнивает распределение конкретного признака в эталонной обучающей выборке (Expected) с распределением в текущем продакшене (Actual). Непрерывный признак разбивается на корзин (bins), например, на 10 децилей. Формула PSI:

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

Разберем механику на одном слагаемом. Допустим, в корзину «возраст 25-30 лет» при обучении попадало 20% пользователей (), а сейчас в продакшене их стало 25% (). Отношение . Натуральный логарифм . Разность долей . Итоговый вклад этой корзины в общую сумму: .

Если распределения идентичны, , логарифм единицы равен нулю, и итоговый . Эмпирическое правило гласит: * — статистически значимых изменений нет. * — желтая зона, требуется внимательное наблюдение. * — произошел сильный сдвиг распределения. Модель необходимо отправить на переобучение (Fine-Tuning) или запустить теневое развертывание (Shadow Deployment) новой версии.

Ресурсы для глубокого изучения

Чтобы перейти от поверхностного использования API к фундаментальному пониманию архитектур и уверенному прохождению System Design интервью, необходимо погрузиться в специализированную литературу и материалы. Ниже приведены проверенные ресурсы, разделенные по категориям.

Книги и фундаментальные труды

* "Designing Machine Learning Systems" (Chip Huyen) — абсолютный стандарт индустрии. Книга подробно разбирает каждый этап жизненного цикла ML-системы, уделяя особое внимание инженерии данных, Feature Stores и стратегиям развертывания. * "Machine Learning Engineering" (Andriy Burkov) — сжатое, но математически точное руководство по переводу моделей из Jupyter-ноутбуков в продакшен. Отлично покрывает вопросы обработки ошибок и мониторинга. * "System Design Interview – An Insider's Guide" (Alex Xu) — хотя книга не сфокусирована исключительно на ML, она обязательна для понимания базовой инфраструктуры: балансировщиков нагрузки, кэширования, шардирования баз данных и очередей сообщений (Kafka), без которых не работает ни одна ML-система.

Научные статьи (Papers)

* "Hidden Technical Debt in Machine Learning Systems" (D. Sculley et al., Google) — классическая статья, объясняющая, почему код алгоритма — это лишь малая часть системы, и описывающая антипаттерны интеграции ML. * "Deep Neural Networks for YouTube Recommendations" (Covington et al.) — фундаментальная работа, впервые детально описавшая двухэтапную архитектуру (Retrieval и Ranking) в масштабах миллиардов пользователей.

Видеоматериалы и блоги

* Блог и рассылка Eugene Yan (eugeneyan.com) — глубокие разборы реальных архитектур рекомендательных систем, векторного поиска и LLM-инфраструктуры от Applied Scientist из Amazon. * Stanford MLSys Seminars (YouTube) — серия академических и индустриальных семинаров Стэнфордского университета на стыке машинного обучения и системного программирования. Идеально для понимания аппаратных оптимизаций (GPU, Tensor Cores, компиляторы нейросетей). * ByteByteGo (YouTube) — канал Алекса Сюя. Визуальное объяснение сложных концепций распределенных систем, сетевых протоколов (gRPC, WebSockets) и архитектур баз данных за 5-10 минут.

Проектирование ML-систем требует постоянного перемещения по уровням абстракции. Инженер должен уметь за одну минуту перейти от обсуждения бизнес-показателей удержания пользователей к архитектуре векторного индекса HNSW, затем к оптимизации памяти GPU через динамический батчинг, и закончить математическим обоснованием метрики смещения данных. Именно способность видеть систему целиком, понимая физический, сетевой и математический смысл каждого узла, отличает специалиста, готового создавать независимые ML-решения корпоративного уровня.

Многие разработчики воспринимают среднеквадратичную ошибку (MSE) как данность: чтобы обучить регрессию, нужно минимизировать сумму квадратов отклонений. Кажется, что это просто удобная эвристика, ведь квадрат убирает отрицательные знаки и сильнее штрафует за крупные промахи. На самом деле, выбор квадратичной функции потерь — это не произвол инженера. Это строгий математический вывод, который неизбежно возникает, если предположить, что шум в данных имеет форму колокола нормального распределения, и применить принцип максимального правдоподобия. Машинное обучение не просто «подгоняет кривые» — оно моделирует неопределенность. И язык, на котором говорит эта неопределенность, — теория вероятностей и математическая статистика.

Случайные величины и плотность вероятности

В детерминированном мире классического программирования переменная x = 5 всегда равна пяти. В машинном обучении мы работаем со случайными величинами — абстракциями, которые описывают результаты экспериментов и принимают различные значения с определенными вероятностями.

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

Поведение непрерывной случайной величины описывается функцией плотности вероятности (Probability Density Function, PDF), обозначаемой как .

Критический нюанс, который часто упускают при переходе от дискретной математики к непрерывной: для непрерывной величины вероятность принять абсолютно точное значение равна нулю. Вероятность того, что рост человека составляет ровно см с бесконечной точностью, равна . Мы можем говорить только о вероятности попадания величины в заданный интервал от до . Эта вероятность вычисляется как площадь под кривой на соответствующем отрезке:

В этой формуле обозначает вероятность, — случайную величину, и — границы интервала, а интеграл суммирует бесконечно малые участки плотности по переменной . Полная площадь под кривой плотности вероятности на всей числовой прямой всегда строго равна единице, так как вероятность того, что величина примет хоть какое-то значение, является достоверным событием:

Любое распределение описывается набором характеристик. Две важнейшие из них — это математическое ожидание и дисперсия . Математическое ожидание показывает центр масс распределения, то есть среднее значение, к которому будет стремиться величина при бесконечном числе независимых испытаний. Дисперсия измеряет разброс значений вокруг этого центра: чем она выше, тем шире «колокол» распределения и тем выше неопределенность.

В многомерном пространстве, где объекты описываются векторами признаков (например, дом описывается площадью, количеством комнат и расстоянием до метро), понятие дисперсии обобщается до ковариационной матрицы . На главной диагонали этой матрицы лежат дисперсии отдельных признаков, показывающие их собственный разброс. Вне диагонали находятся ковариации, отражающие линейную зависимость между парами признаков. Если ковариация между площадью дома и его ценой велика и положительна, это означает, что при росте площади цена также имеет тенденцию возрастать. Понимание структуры ковариационной матрицы критически важно для алгоритмов снижения размерности, таких как метод главных компонент (PCA).

Теорема Байеса: математика изменения убеждений

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

В контексте машинного обучения элементы этой формулы имеют строгие смысловые роли:

— априорная вероятность (Prior). Наше исходное убеждение о вероятности гипотезы до того, как мы увидели какие-либо новые данные.

— правдоподобие (Likelihood). Вероятность наблюдать конкретные данные при условии, что гипотеза верна.

— маргинальная вероятность (Evidence). Полная вероятность наблюдать данные при любых возможных сценариях (гипотезах). Выступает нормировочной константой.

— апостериорная вероятность (Posterior). Наше обновленное убеждение о гипотезе после того, как мы учли новые данные .

Разберем классический медицинский тест на редкое заболевание. Допустим, болезнь встречается у населения. Это наш Prior: . Тест определяет болезнь с точностью . Если человек действительно болен, тест покажет положительный результат с вероятностью . Это Likelihood: . При этом тест несовершенен и дает ложноположительный результат в случаев. Здоровый человек получает положительный тест с вероятностью : .

Пациент сдает анализ и получает положительный тест. Какова реальная вероятность того, что он болен? Интуиция часто подсказывает цифру около , опираясь на высокую точность самого прибора. Применим теорему Байеса для точного расчета.

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

Теперь находим искомую апостериорную вероятность:

Вероятность болезни составляет всего . Из-за того, что болезнь сама по себе крайне редкая (Prior очень мал), подавляющее большинство положительных результатов будут ложноположительными, сгенерированными огромной массой здоровых людей. Этот контринтуитивный феномен называется парадоксом базовой оценки (Base Rate Fallacy).

!Визуализация Байесовского вывода: синтез априорного распределения и правдоподобия в апостериорное.

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

Оценка максимального правдоподобия (MLE)

Один из главных вопросов при проектировании архитектуры: как выбрать функцию потерь? Почему для регрессии стандартом стала MSE, а для классификации — кросс-энтропия? Ответ кроется в концепции Оценки Максимального Правдоподобия (Maximum Likelihood Estimation, MLE).

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

Цель MLE — найти такие параметры , которые максимизируют вероятность появления нашей обучающей выборки. Работать с произведением тысяч вероятностей технически невозможно: перемножение чисел, меньших единицы, быстро приводит к значениям порядка , что вызывает арифметическое переполнение снизу (underflow) в памяти GPU или CPU. Компьютер просто округлит результат до нуля.

Поэтому в ML всегда переходят к логарифму правдоподобия (Log-Likelihood). Поскольку логарифм является монотонно возрастающей функцией, точка максимума аргумента не изменится. При этом, согласно свойствам логарифма, произведение превращается в сумму:

Вывод MSE из нормального распределения

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

Сделаем ключевое допущение: шум распределен нормально с нулевым средним и некоторой дисперсией . Математически это записывается как . Функция плотности нормального распределения для переменной имеет вид:

где — математическое ожидание, — дисперсия, — экспоненциальная функция.

!Карл Фридрих Гаусс

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

Запишем логарифм правдоподобия для всей обучающей выборки из объектов:

Логарифм произведения разбивается на сумму логарифмов, а натуральный логарифм от экспоненты взаимно уничтожается, оставляя только показатель степени:

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

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

Это формула Mean Squared Error (MSE). Минимизация квадратичной ошибки — это не эмпирический трюк, а математически точный поиск наиболее вероятных параметров модели при строгом условии, что ошибки предсказаний распределены по закону Гаусса.

Если бизнес-задача требует предсказания стоимости поездки на такси, где часто встречаются аномальные выбросы (поездки в снегопад с коэффициентом ), предположение о нормальности шума становится ошибочным. Нормальное распределение имеет «легкие хвосты» и считает сильные отклонения почти невозможными, из-за чего MSE будет слишком сильно штрафовать модель за выбросы, искажая предсказания для типичных поездок. Если предположить, что шум имеет распределение Лапласа (с более тяжелыми хвостами и острым пиком), то в показателе экспоненты плотности вероятности будет стоять модуль разности . Проведя аналогичный вывод через логарифмирование, мы получим функцию потерь Mean Absolute Error (MAE). Смена бизнес-логики диктует смену вероятностного распределения, что автоматически приводит к новой функции потерь.

Maximum A Posteriori (MAP) и природа регуляризации

Метод MLE ищет веса, которые идеально объясняют обучающую выборку. Но если выборка мала, зашумлена или содержит мультиколлинеарные признаки, модель может переобучиться. В процессе градиентного спуска веса могут вырасти до гигантских значений (например, для одного признака и для другого), пытаясь подогнать кривую под каждую точку. Чтобы ограничить этот процесс, мы переходим от MLE к MAP — Maximum A Posteriori.

В оценке MAP мы возвращаемся к теореме Байеса и вводим априорные знания о самих весах до того, как модель увидит данные:

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

Первое слагаемое — это уже выведенный нами Log-Likelihood (который превращается в MSE). Второе слагаемое — логарифм априорного распределения весов. Предположим, мы верим, что в хорошей модели веса должны быть небольшими. Математически это означает, что априорно веса распределены нормально вокруг нуля с некоторой дисперсией . Подставим плотность нормального распределения для вектора весов размерности :

Применяя свойства логарифма и отбрасывая константы, не зависящие от , получаем:

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

Добавив эту компоненту к нашему выводу MSE и инвертировав знак для минимизации, мы получаем итоговую функцию потерь:

Это формула L2-регуляризации (Ridge регрессии). Регуляризация — это не искусственный инженерный «костыль», а прямое следствие байесовского вывода с априорным нормальным распределением весов.

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

Закон больших чисел и Центральная предельная теорема

Глубокое обучение оперирует миллионами параметров и терабайтами данных. Почему градиентный спуск вообще сходится к оптимуму, если мы обновляем веса, оценивая ошибку лишь на крошечных порциях данных (mini-batches) по 32 или 256 объектов? Стабильность этого процесса гарантируют две фундаментальные теоремы статистики.

Первая — Закон больших чисел (Law of Large Numbers, LLN). Теорема гласит, что выборочное среднее последовательности независимых одинаково распределенных случайных величин сходится к их истинному математическому ожиданию при увеличении размера выборки. Вычисляя градиент функции потерь на батче, мы получаем стохастический градиент — случайную величину. Благодаря LLN, математическое ожидание этого стохастического градиента равно истинному градиенту по всему датасету. Шум в батчах заставляет траекторию обучения «блуждать», но в среднем модель неуклонно движется в правильном направлении к минимуму функции потерь.

Вторая — Центральная предельная теорема (Central Limit Theorem, CLT). Она утверждает: если сложить достаточно большое количество независимых случайных величин (независимо от того, как они распределены изначально — равномерно, экспоненциально или биномиально), распределение их суммы будет стремиться к нормальному.

!Интерактивная симуляция Центральной предельной теоремы: при увеличении размера выборки гистограмма выборочных средних из экспоненциального распределения плавно сходится к нормальному распределению (показана красной кривой).

В проектировании архитектур нейросетей CLT играет решающую роль на этапе инициализации весов. Значение активации любого нейрона до применения нелинейности — это взвешенная сумма выходов сотен или тысяч нейронов предыдущего слоя: . Согласно CLT, эта сумма стремится к нормальному распределению.

Если дисперсия этого распределения будет слишком велика, значения уйдут в области насыщения активационных функций (например, сигмоиды или гиперболического тангенса), градиенты станут близки к нулю, и обучение остановится (проблема затухающих градиентов). Если дисперсия будет расти от слоя к слою, значения взорвутся до NaN. Дисперсия суммы независимых переменных растет пропорционально . Чтобы удержать дисперсию активаций равной единице на каждом слое, дисперсия самих весов при инициализации должна быть обратно пропорциональна количеству входов (то есть ). Именно на этом строгом математическом факте базируются методы инициализации Xavier (Glorot) и He, без которых обучение современных глубоких сетей было бы невозможным.

Ресурсы для глубокого погружения

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

Книги и учебники:

«Deep Learning» (Ian Goodfellow, Yoshua Bengio, Aaron Courville) — обязательная база. Глава 3 полностью посвящена теории вероятностей в контексте ML, а Глава 5 детально разбирает связь MLE, MAP и алгоритмов машинного обучения.

«Pattern Recognition and Machine Learning» (Christopher Bishop) — классический труд, раскрывающий машинное обучение исключительно через призму байесовского вывода и вероятностных моделей. Идеально для понимания внутренней логики алгоритмов.

«Теория вероятностей и математическая статистика» (Н. Кремер или В. Чистяков) — классические русскоязычные учебники для строгой постановки математической базы (интегралы плотности, свойства дисперсии, ЗБЧ и ЦПТ).

Видеолекции и курсы:

Канал StatQuest with Josh Starmer (YouTube) — англоязычный канал, где сложнейшие концепции (MLE, логистическая регрессия, PCA) объясняются на простых визуальных примерах без потери математической строгости.

Машинное обучение (К. Воронцов, МФТИ / ШАД) — фундаментальный русскоязычный курс лекций на YouTube. Особое внимание стоит уделить лекциям по байесовской классификации и логической регрессии.

CS229: Machine Learning (Andrew Ng, Stanford) — записи лекций доступны на YouTube. Курс отличается сильным математическим уклоном, подробным выводом функций потерь из распределений и матричным исчислением.

Канал 3Blue1Brown (YouTube) — плейлисты по линейной алгебре и вероятности. Визуализация ковариационных матриц и трансформаций пространства формирует глубокую геометрическую интуицию, необходимую для работы с многомерными тензорами.

Глубокое понимание вероятностных основ позволяет инженеру не просто вызывать model.fit(), а осознанно конструировать архитектуры. Понимание того, что кросс-энтропия — это логарифм правдоподобия для распределения Бернулли, а регуляризация — это априорное распределение на веса, дает ключи к самостоятельной разработке кастомных функций потерь под специфичные бизнес-задачи, где стандартные предположения о нормальности шума могут не выполняться.

Классическое машинное обучение: от линейной регрессии до градиентного бустинга и ансамблей

В соревнованиях по машинному обучению и в реальных промышленных задачах существует эмпирическое правило: если данные представляют собой неструктурированные массивы (изображения, текст, звук) — доминируют глубокие нейронные сети; если данные табличные и гетерогенные — побеждает градиентный бустинг над решающими деревьями. Несмотря на колоссальный прогресс в архитектурах глубокого обучения, ансамбли простых деревьев остаются непревзойденным стандартом для кредитного скоринга, рекомендательных систем и предсказания оттока (churn rate). Чтобы осознанно выбирать архитектуру решения, проводить аудит моделей и не зависеть от черных ящиков готовых библиотек, необходимо спуститься на уровень математики, лежащей в основе классических алгоритмов.

Машины опорных векторов (SVM) и геометрия разделения

Разделение данных начинается с поиска оптимальной границы. Линейная регрессия минимизирует среднеквадратичную ошибку, а логистическая регрессия оценивает вероятности принадлежности к классу через сигмоиду. Однако геометрически более строгим методом построения разделяющей границы выступают машины опорных векторов (Support Vector Machines, SVM).

Основная идея SVM заключается не просто в проведении разделяющей гиперплоскости между классами, а в максимизации зазора (margin) между ними. Пусть задана обучающая выборка , где вектор признаков , а метка класса . Уравнение гиперплоскости задается как , где — вектор весов, нормальный к гиперплоскости, а — смещение (bias).

Расстояние от любой точки до этой гиперплоскости вычисляется по формуле .

Алгоритм SVM требует, чтобы для всех объектов выполнялось условие правильной классификации с некоторым запасом. Математически это записывается так: .

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

при ограничениях для всех .

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

Мягкий зазор (Soft Margin) и баланс смещения-дисперсии

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

Ограничения модифицируются: . Переменная показывает, насколько объект нарушает границу зазора. Целевая функция принимает вид:

Гиперпараметр выступает регуляризатором, контролирующим компромисс между шириной зазора и ошибками классификации. При штраф за ошибки огромен, модель стремится безошибочно классифицировать обучающую выборку, сужая зазор (высокая дисперсия, риск переобучения). При малом штраф незначителен, модель допускает ошибки на обучающей выборке ради более широкого зазора (высокое смещение, риск недообучения). Понимание роли критически важно при отладке моделей в условиях зашумленных данных.

Ядровой трюк (Kernel Trick) и двойственная задача

Для перехода к нелинейным разделяющим поверхностям применяется «ядровой трюк» (kernel trick). Данные отображаются в пространство более высокой размерности с помощью нелинейной функции .

Инженерная ценность ядрового трюка раскрывается при переходе к двойственной задаче оптимизации SVM через множители Лагранжа . В двойственной форме целевая функция зависит только от скалярных произведений пар объектов:

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

Одним из самых мощных ядер является радиальная базисная функция (RBF):

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

!Интерактивная 3D-визуализация ядрового трюка RBF: точки двух классов (кольцо и центр) поднимаются по оси Z при увеличении параметра gamma, становясь линейно разделимыми плоскостью в 3D-пространстве. Сцену можно вращать мышью.

Решающие деревья и теория информации

Линейные модели и их ядровые расширения обладают критическим недостатком при работе с гетерогенными табличными данными. Они требуют строгой нормализации признаков и чувствительны к выбросам. Решающие деревья (Decision Trees) предлагают негеометрический подход: пространство признаков рекурсивно разбивается на ортогональные области проверками вида .

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

где — доля объектов класса .

При разбиении узла по признаку на подмножества , вычисляется прирост информации (Information Gain, ):

Рассмотрим расчет на микро-выборке кредитного скоринга. В корневом узле 10 клиентов: 6 вернули кредит (), 4 допустили дефолт (). Энтропия корня: . Алгоритм тестирует разбиение по признаку «Доход > 100 тыс. руб.». В левое подмножество () попадают 5 клиентов, все 5 вернули кредит. Энтропия (полная определенность). В правое подмножество () попадают оставшиеся 5 клиентов (1 вернул, 4 дефолта). Энтропия . Прирост информации составит: . Алгоритм перебирает все возможные пороги для всех признаков и выбирает тот, где максимален.

!Интерактивная визуализация разбиения узла дерева решений: перемещайте порог слайдером и наблюдайте, как меняются энтропия левого/правого подмножеств и Information Gain. При достижении оптимального порога линия подсвечивается зелёным.

Архитектурное преимущество деревьев — инвариантность к монотонным преобразованиям. Взятие логарифма от признака изменит абсолютное значение порога , но порядок сортировки объектов и структура дерева останутся неизменными.

Архитектуры ансамблей: Бэггинг и Бустинг

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

!Различия в принципах работы ансамблевых методов машинного обучения: бэггинг и бустинг.

Бэггинг, Случайный лес и Out-of-Bag оценка

Бэггинг (Bootstrap Aggregating) снижает дисперсию. Случайный лес (Random Forest) обучает множество глубоких деревьев независимо друг от друга. Рандомизация двухуровневая: каждое дерево видит лишь случайную подвыборку данных (бутстрап), и в каждом узле оптимальный порог ищется среди случайного подмножества признаков (обычно ).

Математика бэггинга опирается на дисперсию суммы коррелированных случайных величин. Для деревьев с дисперсией и попарной корреляцией :

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

Важным инженерным свойством бэггинга является Out-of-Bag (OOB) оценка. При формировании бутстрап-выборки объемом из исходного датасета размером , вероятность того, что конкретный объект не попадет в выборку, равна . При этот предел стремится к . Таким образом, каждое дерево обучается примерно на 63.2% уникальных данных. Оставшиеся 36.8% (OOB-выборка) используются как бесплатный валидационный сет, позволяя оценивать качество модели без затрат на кросс-валидацию.

Градиентный бустинг: от псевдоостатков к методу Ньютона-Рафсона

Если бэггинг борется с дисперсией, то бустинг (Boosting) снижает смещение (bias). Деревья строятся строго последовательно: каждое новое дерево пытается исправить ошибки суммы предыдущих .

Темп обучения (learning rate) выступает формой регуляризации (shrinkage), предотвращая слишком быстрые шаги в сторону минимума и позволяя ансамблю обобщать лучше.

В классическом градиентном бустинге новое дерево предсказывает антиградиент функции потерь — псевдоостатки:

Современные архитектуры (XGBoost, LightGBM) выводят процесс на уровень метода Ньютона-Рафсона, применяя разложение функции потерь в ряд Тейлора до второго порядка. Целевая функция на шаге для дерева :

где и — первая и вторая производные (градиент и гессиан) функции потерь по предсказанию. Регуляризация дерева штрафует за количество листьев и величину весов .

Сгруппировав объекты по листьям (множество индексов для листа ), получаем аналитическое решение для оптимального веса в листе:

Эта формула — ключ к глубокой отладке. Рассмотрим бинарную классификацию с функцией log-loss. Гессиан равен , где — предсказанная вероятность. Если ансамбль слишком уверен (), гессиан объекта . Если в лист попали 10 таких объектов, сумма гессианов равна . Без L2-регуляризации () деление на приведет к взрыву веса . Модель начнет выдавать экстремальные значения логитов, что на этапе инференса превратится в нули или единицы, ломая калибровку вероятностей. Установка меняет знаменатель на , жестко стабилизируя веса.

Понимание того, что градиентный бустинг — это не просто «деревья, исправляющие ошибки», а последовательная оптимизация функционала с учетом кривизны пространства (гессиана), позволяет ML-инженеру осознанно управлять процессом обучения, а не подбирать гиперпараметры вслепую.

Ресурсы для глубокого изучения

Для перехода от использования готовых API к самостоятельному проектированию архитектур и успешному прохождению технических секций (System Design / ML Math), рекомендуется проработать следующие материалы.

Фундаментальная математика и статистика

Понимание алгоритмов невозможно без прочной базы в линейной алгебре и теории оптимизации.

Книга: «Convex Optimization» (Stephen Boyd, Lieven Vandenberghe). Главный труд по выпуклой оптимизации. Необходим для глубокого понимания двойственной задачи SVM, множителей Лагранжа и условий Каруша-Куна-Таккера (KKT).

Книга: «The Elements of Statistical Learning» (Trevor Hastie, Robert Tibshirani, Jerome Friedman). Библия классического ML. Глава 10 детально раскрывает бустинг как статистический процесс (Forward Stagewise Additive Modeling), а Глава 15 содержит исчерпывающий математический анализ Random Forest.

Курс (YouTube): «Essence of linear algebra» (3Blue1Brown). Визуальное объяснение трансформаций пространств, собственных векторов и матриц. Формирует геометрическую интуицию, необходимую для работы с ядрами SVM и PCA.

Теория машинного обучения и алгоритмы

Книга: «Pattern Recognition and Machine Learning» (Christopher Bishop). Классический учебник с сильным акцентом на байесовский подход. Обязателен для понимания вероятностной природы функций потерь (почему MSE эквивалентно максимизации правдоподобия при нормальном распределении шума).

Видеолекции (RU): Курс «Машинное обучение» (Константин Воронцов, МФТИ / ШАД). Лучшее русскоязычное изложение математического аппарата. Лекции по SVM и композициям алгоритмов содержат подробный вывод формул на доске, что идеально для подготовки к хардкорным интервью.

Курс (RU/EN): Открытый курс машинного обучения (ODS.ai). Баланс между математикой и практикой. Отлично разобраны нюансы работы с признаками и построения ансамблей на реальных данных.

Анатомия градиентного бустинга

Оригинальная статья: «XGBoost: A Scalable Tree Boosting System» (Tianqi Chen, Carlos Guestrin). Чтение оригинальных пейперов — обязательный навык ML-инженера. В статье показано, как аппроксимация Тейлора превращается в эффективный алгоритм с учетом разреженности данных (Sparsity-aware Split Finding).

Плейлисты (YouTube): StatQuest with Josh Starmer (Gradient Boosting, XGBoost). Перед тем как браться за производные второго порядка, полезно посмотреть пошаговый расчет деревьев бустинга на конкретных числах (сложение логитов, перевод в вероятности).

Для закрепления материала рекомендуется реализовать Decision Tree и базовый Gradient Boosting с нуля на чистом NumPy. Написание собственного .fit() и .predict() — единственный способ гарантированно устранить пробелы в понимании математического вывода.

Современные большие языковые модели содержат сотни миллиардов параметров. Чтобы сделать всего один шаг обучения такой сети, необходимо вычислить градиент функции потерь по каждому из этих миллиардов весов. Если бы мы вычисляли производные численно, слегка изменяя каждый параметр и оценивая реакцию сети, один шаг оптимизации на современном кластере GPU занимал бы годы. Тот факт, что обучение занимает дни или недели, является заслугой одного из самых элегантных алгоритмов в вычислительной математике — обратного распространения ошибки (Backpropagation).

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

От перцептрона к многослойным архитектурам

Исторически концепция искусственного нейрона восходит к работами Маккаллока и Питтса, но первую обучаемую модель — перцептрон — реализовал Фрэнк Розенблатт в 1957 году.

!Фрэнк Розенблатт с аппаратным перцептроном Mark I

Оригинальный перцептрон был однослойным и мог решать только линейно разделимые задачи. Чтобы моделировать сложные нелинейные зависимости, архитектуру расширили до многослойного перцептрона (Multilayer Perceptron, MLP).

MLP состоит из входного слоя, одного или нескольких скрытых слоев и выходного слоя. Математически прямой проход (Forward Pass) через один слой описывается двумя операциями.

Линейное преобразование:

Нелинейная активация:

Здесь — матрица весов слоя , — вектор смещений (bias), — вектор активаций предыдущего слоя (или вектор входных признаков , если ), — вектор взвешенных сумм до применения активации, а — нелинейная функция активации (например, ReLU или Sigmoid).

Критически важно с самого начала контролировать размерности тензоров. Если слой имеет нейронов, а слой имеет нейронов, то:

имеет размерность

имеет размерность

и имеют размерность

Умножение матрицы на вектор дает вектор , к которому поэлементно прибавляется смещение.

Например, если входной вектор содержит 3 признака, а скрытый слой состоит из 4 нейронов, матрица весов будет иметь размер . Каждый из 4 нейронов имеет 3 связи с предыдущим слоем. Результатом умножения станет вектор из 4 элементов. Именно эта строгая алгебраическая согласованность позволяет эффективно распараллеливать вычисления на матричных процессорах и тензорных ядрах GPU.

Вычислительный граф и кэширование памяти

Когда реализуется нейронная сеть с нуля, прямой проход не просто вычисляет итоговый ответ. Он строит вычислительный граф — направленный ациклический граф, где узлы представляют собой математические операции, а ребра — потоки тензоров.

!Вычислительный граф прямого и обратного прохода

Главное инженерное следствие этой архитектуры: чтобы вычислить градиенты при обратном проходе, необходимо знать значения и , которые были получены при прямом проходе. Это означает, что фреймворки глубокого обучения (PyTorch, TensorFlow) вынуждены кэшировать эти тензоры в оперативной памяти GPU.

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

Математический вывод обратного распространения ошибки

Алгоритм Backpropagation — это многократное применение цепного правила дифференцирования (Chain Rule) к вычислительному графу. Глобальная цель — найти частные производные функции потерь по каждому весу и смещению в сети.

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

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

Шаг 1: Ошибка выходного слоя

Начнем с последнего слоя . По цепному правилу:

Первый множитель — это градиент функции потерь по предсказаниям сети. Если решается задача регрессии с функцией потерь MSE (Mean Squared Error), где , то производная будет просто вектором разностей .

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

Шаг 2: Распространение ошибки на скрытые слои

Связь между ошибкой текущего слоя и ошибкой следующего слоя — это сердце алгоритма Backpropagation.

Известно, что , где . Изменение влияет на только через изменение . Применяя цепное правило для векторов, получаем:

Матрица осуществляет преобразование вперед, распределяя сигнал от нейронов слоя к нейронам слоя . Чтобы пробросить градиент назад, используется транспонированная матрица .

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

Проверка размерностей: имеет размер . Вектор имеет размер . Их произведение дает вектор , который совпадает по размерности с производной активации .

Шаг 3: Вычисление градиентов по параметрам

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

Градиент по матрице весов требует внешнего произведения вектора ошибки текущего слоя на транспонированный вектор активаций предыдущего слоя:

Интуиция этой формулы опирается на правило Хебба: градиент (и, следовательно, обновление веса) зависит как от того, насколько сильно был активирован входной нейрон , так и от того, насколько велика ошибка выходного нейрона .

Размерности: это , а это . Их внешнее произведение дает матрицу , что в точности совпадает с размерностью самой матрицы весов .

!Пошаговое распространение градиента по слоям

Векторизация: переход к батчам (Mini-batch)

В реальном обучении данные никогда не пропускаются через сеть по одному примеру. Используются батчи (пакеты) размера . Это меняет размерности тензоров и требует модификации формул градиентов для матричных вычислений.

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

Прямой проход для батча:

Вектор имеет размер , но при сложении с матрицей он неявно дублируется на все столбцов. Эта операция называется транслированием (broadcasting).

Обратный проход также претерпевает изменения. Матрица ошибок (аналог для батча) вычисляется как:

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

В формуле для матрица суммируется по столбцам (по оси батча ), чтобы получить итоговый вектор-столбец размерности .

Инженерный аудит: отладка обратного прохода

Понимание этих формул — основной инструмент ML-инженера при отладке кастомных архитектур. Когда сеть «не сходится» или выдает NaN в функции потерь, проблема почти всегда кроется в нарушении потока градиентов.

Проблема несовпадения размерностей (Shape Mismatch)

Самая частая ошибка при реализации кастомных слоев — неверное изменение формы тензора при пробросе градиента.

Например, в PyTorch есть методы .view() и .reshape(). Если у вас есть тензор изображений с размерностью (batch_size, channels, height, width), и вы хотите поменять оси местами, использование .view() без понимания расположения элементов в памяти приведет к катастрофе. Прямой проход отработает без ошибок (размерности совпадут), но физически пиксели разных каналов и даже разных изображений в батче перемешаются. Обратный проход вычислит градиент для этого «визуального шума», и сеть не сможет обучиться.

Правило аудита: для перестановки осей всегда используется .permute() или .transpose(), которые корректно меняют шаги (strides) тензора в памяти, сохраняя математическую целостность градиента. Градиент тензора всегда должен иметь ту же размерность и ту же структуру данных, что и сам тензор.

Утечки памяти графа вычислений

В фреймворках вроде PyTorch тензоры хранят историю своего создания (атрибут grad_fn). Если сохранять промежуточные потери для логирования напрямую, например total_loss += loss, в оперативной памяти сохраняется весь вычислительный граф для каждого батча. Через несколько десятков итераций это приведет к ошибке Out Of Memory (OOM).

Математическое понимание того, что loss — это не просто число, а вершина огромного направленного графа, диктует правильный подход. Для логирования нужно отсекать скаляр от графа, используя loss.item() (возвращает стандартное число Python) или loss.detach() (возвращает тензор без истории градиентов).

Контроль затухания и взрыва градиентов

Формула распространения ошибки скрывает в себе механизм затухания градиента (Vanishing Gradient).

Если используется функция активации Sigmoid, максимальное значение ее производной равно (достигается при ). При прохождении ошибки через 10 слоев, градиент умножится на . Сигнал об ошибке просто не дойдет до первых слоев сети, и их веса перестанут обновляться. Математический вывод прямо показывает корень проблемы и объясняет, почему переход на ReLU, где производная равна для положительных , стал стандартом де-факто: умножение на позволяет градиенту протекать сквозь десятки слоев без затухания.

Обратная ситуация — взрыв градиентов (Exploding Gradients) и появление NaN. Если веса матрицы инициализированы слишком большими значениями, а активация (например, ReLU) не ограничивает амплитуду сигнала, при многократном умножении на вектор ошибки экспоненциально растет. Это приводит к переполнению типов данных (overflow). Зная это, ML-инженеры применяют методы Gradient Clipping (принудительное ограничение нормы градиента перед шагом оптимизатора) и используют математически обоснованные методы инициализации весов (Xavier или He), которые сохраняют дисперсию активаций и градиентов постоянной от слоя к слою.

Ресурсы для глубокого погружения

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

Книги и учебники

Deep Learning (Ian Goodfellow, Yoshua Bengio, Aaron Courville). Библия глубокого обучения. Глава 6 полностью посвящена многослойным сетям и строгому математическому выводу Backpropagation с использованием графов вычислений.

Pattern Recognition and Machine Learning (Christopher Bishop). Классический труд, который дает мощную статистическую и вероятностную базу. Глава 5 детально разбирает нейронные сети с точки зрения байесовского вывода и гессианов (вторых производных).

Dive into Deep Learning (d2l.ai). Интерактивный учебник (доступен онлайн). Уникален тем, что каждая математическая концепция сразу сопровождается реализацией на PyTorch, NumPy и JAX с нуля.

Видеокурсы и лекции

Neural Networks: Zero to Hero (Andrej Karpathy, YouTube). Идеальный ресурс для инженеров. В первых видео автор с нуля пишет движок автоматического дифференцирования micrograd на чистом Python, шаг за шагом реализуя граф вычислений и Backpropagation на уровне отдельных скаляров, а затем переходит к матрицам.

CS231n: Convolutional Neural Networks for Visual Recognition (Stanford). Лекции доступны на YouTube. Особое внимание стоит уделить лекциям 3 и 4, где детально разбирается векторное исчисление градиентов, аналитические и численные методы их проверки (Gradient Checking).

3Blue1Brown: Neural Networks (YouTube). Серия из четырех визуальных эссе. Не заменит строгую математику, но формирует безупречную геометрическую интуицию того, как матрицы весов трансформируют пространство и как градиентный спуск ищет минимум.

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

Функции потерь и современные методы оптимизации градиентного спуска

Обучение нейронной сети с десятками миллионов параметров — это навигация в пространстве колоссальной размерности. Если использовать стандартный стохастический градиентный спуск (SGD), двигаясь строго в направлении антиградиента, процесс быстро заходит в тупик. В многомерных пространствах ландшафт функции потерь изобилует патологической кривизной: узкими оврагами, где по одной оси градиент огромен (крутые склоны), а по другой — почти равен нулю (длинное пологое дно). Математически это выражается через матрицу Гессе (матрицу вторых производных) с высоким числом обусловленности — отношением наибольшего собственного значения к наименьшему. В таких условиях алгоритм начинает бесконечно осциллировать между стенами оврага, практически не продвигаясь к глобальному минимуму. Чтобы нейросеть обучалась за адекватное время, инженеру необходимо не только правильно спроектировать геометрию этого ландшафта через выбор функции потерь, но и подобрать алгоритм оптимизации, способный накапливать «инерцию» и адаптироваться к масштабу градиентов.

Инженерия функций потерь: от теории к вычислительной стабильности

Функция потерь (Loss function) задает метрику расстояния между предсказанием модели и истинным ответом. В задачах классификации стандартом де-факто является перекрестная энтропия (Cross-Entropy).

Для многоклассовой классификации выходной вектор логитов (сырых, ненормализованных предсказаний сети) сначала преобразуется в вероятностное распределение с помощью функции Softmax:

Где — предсказанная вероятность класса , — логит для класса , — общее количество классов, а — основание натурального логарифма.

Затем применяется функция перекрестной энтропии:

Где — значение потерь, — индикатор истинного класса (1 для верного класса, 0 для остальных). Поскольку равен единице только для одного истинного класса , сумма схлопывается до одного слагаемого: .

Математическая элегантность градиента Cross-Entropy

На технических собеседованиях на позицию ML-инженера часто просят вывести градиент связки Softmax и Cross-Entropy по логитам . Если вычислять их по отдельности, формулы получаются громоздкими, так как изменение одного логита влияет на вероятности всех остальных классов через знаменатель Softmax.

Однако, если взять производную итоговой функции потерь по логиту , сложная математика сокращается до тривиального выражения:

Где — компонента вектора градиента для логита , — предсказанная вероятность, — истинная метка (0 или 1).

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

Проблема переполнения и LogSumExp trick

С аналитической точки зрения формулы выше безупречны. С инженерной — их прямая реализация в коде приведет к катастрофе. Экспонента растет невероятно быстро.

Рассмотрим вектор логитов для трех классов, полученный на первых итерациях обучения: . Вычисление вызовет переполнение типа данных float32 (максимальное значение которого около ) и вернет значение inf (бесконечность). Деление бесконечности на бесконечность в знаменателе Softmax даст NaN (Not a Number), и обучение разрушится.

Для решения этой проблемы при расчете градиентов и потерь Softmax и Cross-Entropy всегда объединяют в единый вычислительный узел, применяя математический трюк LogSumExp. Подставим формулу Softmax в функцию потерь для истинного класса :

Чтобы избежать переполнения в сумме экспонент, найдем максимальный логит в векторе: . Вынесем за скобки внутри логарифма:

Применим это к нашему вектору . Максимум . Вычитаем его из всех логитов, получаем новый вектор . Теперь наибольшее значение степени в экспоненте равно нулю. Максимальное значение экспоненты составит . Вычисление абсолютно безопасно для float32. Переполнение исключено математически. Именно поэтому во фреймворках вроде PyTorch функция nn.CrossEntropyLoss принимает на вход сырые логиты, а не вероятности, выполняя этот трюк под капотом на уровне C++/CUDA.

Focal Loss: борьба с экстремальным дисбалансом

Классическая перекрестная энтропия уязвима к дисбалансу классов. В задачах вроде детекции объектов (например, архитектура RetinaNet) на изображении могут быть миллионы фоновых пикселей (класс «фон») и лишь пара сотен пикселей искомого объекта. Даже если сеть легко и уверенно классифицирует фон (предсказывая вероятность истинного класса ), огромная масса этих «легких» примеров создаст суммарный градиент, который перекроет полезный сигнал от редких объектов.

Для решения этой задачи была разработана Focal Loss. Она модифицирует перекрестную энтропию, добавляя модулирующий множитель:

Где — значение функции Focal Loss, — предсказанная вероятность истинного класса, — весовой коэффициент для статической балансировки классов, а (фокусирующий параметр) — гиперпараметр, обычно равный 2.

!Интерактивный график Focal Loss: слайдер γ меняет форму кривой в реальном времени, показывая как при росте γ потери для «лёгких» примеров (p_t → 1) стремятся к нулю быстрее, чем у базовой Cross-Entropy (пунктир).

Механика работы множителя :

Если пример сложный и сеть ошибается (), множитель . Функция потерь работает как обычная перекрестная энтропия, штрафуя сеть в полную силу.

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

Эволюция алгоритмов оптимизации

Получив стабильный и информативный градиент из функции потерь, мы передаем его оптимизатору. Базовое правило обновления весов стохастического градиентного спуска (SGD) выглядит так:

Где — вектор параметров (весов) на текущем шаге , — веса на предыдущем шаге, — скорость обучения (learning rate), — градиент функции потерь по весам на шаге , вычисленный на случайном мини-батче данных.

Главный недостаток SGD — он опирается только на локальную информацию в текущей точке. Из-за стохастической природы (использования мини-батчей вместо всего датасета) вектор является зашумленной оценкой истинного градиента.

Momentum и Nesterov Accelerated Gradient

Чтобы преодолеть осцилляции в оврагах и быстрее проскакивать пологие участки (включая седловые точки), был введен метод Momentum. Он заимствует концепцию инерции из физики: мы обновляем веса не на основе одного лишь текущего градиента, а используем экспоненциально взвешенное скользящее среднее (EWMA) всех прошлых градиентов.

Где — вектор момента (скорости), — коэффициент сохранения импульса (обычно 0.9 или 0.99).

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

Развитием этой идеи стал Ускоренный градиент Нестерова (Nesterov Accelerated Gradient, NAG). Обычный Momentum вычисляет градиент в текущей точке , а затем делает шаг в направлении суммы градиента и накопленного импульса. NAG предлагает более «умный» подход: поскольку мы знаем, что в любом случае сделаем шаг в направлении импульса , логичнее вычислить градиент не в текущей точке, а в «будущей» точке, куда нас отнесет инерция.

Где — градиент, вычисленный с заглядыванием вперед (look-ahead), — оператор взятия градиента от функции потерь. Это позволяет алгоритму вовремя «затормозить», если впереди начинается подъем, что делает оптимизацию более стабильной.

RMSProp: адаптация к масштабу

Momentum решает проблему направления, но не решает проблему масштаба. В глубоких сетях градиенты разных слоев могут отличаться на порядки. Более того, в задачах обработки естественного языка (NLP) мы часто работаем с разреженными данными (например, эмбеддинги редких слов). Алгоритм RMSProp (Root Mean Square Propagation) вводит адаптивный learning rate для каждого отдельного параметра.

Он накапливает скользящее среднее не самих градиентов, а их квадратов:

Где — нецентрированная дисперсия градиентов, — поэлементное возведение вектора градиента в квадрат, — коэффициент затухания (обычно 0.999), — малая константа (например, ) для предотвращения деления на ноль.

Если градиент параметра стабильно велик, растет, и эффективный шаг уменьшается, предотвращая «взрыв». Если параметр (например, вес редкого слова) обновляется редко и градиенты малы, знаменатель становится крошечным, увеличивая шаг. Это позволяет обучать разреженные признаки с той же эффективностью, что и плотные.

Adam: объединение подходов и коррекция смещения

Алгоритм Adam (Adaptive Moment Estimation) объединяет оба подхода, отслеживая и первый момент (импульс, как в Momentum), и второй момент (нецентрированную дисперсию, как в RMSProp).

Шаг 1. Накопление моментов:

Где — гиперпараметр для первого момента (обычно 0.9), — для второго (обычно 0.999).

Шаг 2. Коррекция смещения (Bias Correction): Векторы и инициализируются нулями. Из-за этого на первых итерациях значения моментов сильно смещены к нулю. Рассмотрим первый шаг () при . Значение составит . Это искусственно заниженная оценка. Чтобы исправить это, Adam применяет коррекцию, зависящую от номера шага :

На шаге знаменатель равен , поэтому . Смещение устранено математически точно. По мере роста , значение стремится к нулю, и знаменатель стремится к единице, плавно отключая коррекцию, когда накоплена достаточная статистика.

Шаг 3. Обновление весов:

!Анимация траекторий трёх оптимизаторов (SGD, Momentum, Adam) на функции Розенброка: линии уровня на фоне, каждый алгоритм движется по-своему — SGD осциллирует, Momentum делает дуги, Adam идёт напрямую к минимуму.

AdamW: почему L2-регуляризация ломается в адаптивных методах

В классическом SGD L2-регуляризация (штраф за большие веса в функции потерь) и Weight Decay (прямое уменьшение весов на каждом шаге) математически эквивалентны.

Добавим L2-штраф к функции потерь: , где — коэффициент регуляризации. Градиент составит: . Обновление в SGD: . Мы видим, что вес просто умножается на коэффициент затухания , что в точности соответствует логике Weight Decay.

Однако в Adam эта эквивалентность разрушается. Если мы передадим регуляризованный градиент в формулы Adam, этот градиент попадет в расчет второго момента .

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

Алгоритм AdamW решает эту проблему, разделяя (decoupling) градиент функции потерь и Weight Decay. Градиент вычисляется только по исходной функции потерь и проходит через все механизмы моментов. А штраф за вес применяется в самом конце, вне адаптивного знаменателя:

Именно AdamW сегодня является стандартом для обучения Трансформеров и тяжелых сверточных сетей, так как обеспечивает лучшую генерализацию (способность работать на новых данных) по сравнению с обычным Adam.

Расписание скорости обучения (Learning Rate Scheduling)

Даже самый совершенный оптимизатор требует управления базовой скоростью обучения в процессе тренировки. Постоянный learning rate приводит к тому, что в начале обучения сеть спускается слишком медленно, а в конце — бесконечно прыгает вокруг минимума, не имея возможности в него «провалиться».

Cosine Annealing и SGDR

Современный стандарт изменения шага — косинусное затухание (Cosine Annealing). Скорость обучения плавно снижается по кривой косинуса от максимального значения до минимального:

Где — скорость обучения на текущем шаге, и — минимальная и максимальная скорости, — текущий шаг, — общее количество шагов, — математическая константа. В отличие от ступенчатого снижения (StepLR), косинусное затухание не вводит резких шоков в процесс оптимизации.

Часто применяется модификация SGDR (Stochastic Gradient Descent with Warm Restarts). Когда достигает минимума, скорость обучения резко сбрасывается обратно до , и косинусный цикл повторяется. Это позволяет модели «выпрыгнуть» из узких локальных минимумов и найти более широкие, плоские минимумы, которые лучше генерализуются на тестовых данных.

Необходимость Warmup для адаптивных методов

При использовании оптимизаторов семейства Adam косинусное расписание обязательно комбинируют с фазой разогрева (Warmup) — линейным увеличением от нуля до на первых нескольких тысячах шагов.

Математическая причина кроется в дисперсии знаменателя . На самых первых шагах обучения статистика градиентов собрана всего по нескольким батчам. Она крайне нестабильна. Если при этом использовать высокий , деление на случайный, плохо оцененный выбросит веса сети в области экстремальных значений, откуда они могут не вернуться (например, из-за массового отмирания нейронов ReLU). Warmup искусственно сдерживает шаг обновления до тех пор, пока скользящее среднее не накопит достаточную репрезентативную историю градиентов.

Рекомендуемая литература и ресурсы для углубленного изучения

Для перехода от использования готовых API к самостоятельному проектированию архитектур и уверенному прохождению технических интервью требуется прочный математический фундамент и понимание «низкоуровневого» кода. Ниже приведен список проверенных ресурсов.

Математический фундамент и классическое ML:

Книга: Ian Goodfellow, Yoshua Bengio, Aaron Courville. "Deep Learning" — библия глубокого обучения. Главы 4 (Численные методы) и 8 (Оптимизация для обучения глубоких моделей) обязательны для понимания математики градиентов.

Книга: Christopher M. Bishop. "Pattern Recognition and Machine Learning" — фундаментальный труд по байесовскому подходу и математической статистике в ML.

Книга: Marc Peter Deisenroth et al. "Mathematics for Machine Learning" — отличный мост между университетской линейной алгеброй/матанализом и реальными ML-алгоритмами.

YouTube-канал: 3Blue1Brown — плейлисты по линейной алгебре, матанализу и нейросетям (есть русская озвучка). Лучший ресурс для визуального понимания векторов, матриц и производных.

Проектирование архитектур и отладка (Bottom-up подход):

Видеокурс: Andrej Karpathy "Neural Networks: Zero to Hero" (YouTube). Бывший директор по ИИ в Tesla пишет нейросети с нуля на Python, начиная с вывода производных (микро-фреймворк micrograd) и заканчивая GPT. Идеально для понимания backpropagation под капотом.

Курс: Stanford CS231n (Convolutional Neural Networks for Visual Recognition) и CS224n (NLP with Deep Learning). Доступны на YouTube. Лекции по оптимизации и функциям потерь там разобраны с академической строгостью.

YouTube-канал: Yannic Kilcher — детальные разборы архитектур и математики современных научных статей (papers) по машинному обучению.

Практика и русскоязычные ресурсы:

Курс: Deep Learning School (DLS) от ФПМИ МФТИ — отличный баланс между математикой и практикой на PyTorch.

Сообщество: Open Data Science (ODS.ai) — их открытые курсы (ods.ai/tracks) по классическому ML и нейросетям содержат глубокие практические задания.

Статьи: Блог Sebastian Ruder (ruder.io) — его обзор алгоритмов градиентного спуска (An overview of gradient descent optimization algorithms) является золотым стандартом для подготовки к секции оптимизации на интервью.

Сверточные и рекуррентные архитектуры: глубокое погружение в обработку сигналов и последовательностей

Обработка одного цветного изображения в разрешении 4K (3840 на 2160 пикселей) с помощью классического многослойного перцептрона обнажает фундаментальные ограничения полносвязных архитектур. Такое изображение содержит входных признаков. Если первый скрытый слой содержит всего 1000 нейронов, матрица весов потребует параметров. В формате float32 (4 байта на число) это означает выделение около 100 гигабайт видеопамяти только для хранения весов одного слоя, не говоря уже о градиентах, состояниях оптимизатора и невозможности собрать датасет, достаточный для предотвращения переобучения такой модели.

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

Математика свертки: от кросс-корреляции к разделению весов

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

Для двумерного входного тензора и ядра размера операция вычисляется как:

Где — значение в выходной карте признаков (feature map) на позиции с координатами и . Индексы и пробегают по высоте и ширине ядра соответственно. Ядро скользит по входному тензору, вычисляя скалярное произведение между своими весами и локальным участком данных.

В этой формуле заложены два критически важных инженерных принципа:

Разреженное взаимодействие (sparse interactions). Выходной нейрон связан не со всем входом, а только с локальным окном (рецептивным полем). Это снижает сложность вычислений с до , где — размер входа.

Разделение параметров (parameter sharing). Одно и то же ядро применяется ко всем позициям . Если сеть учится определять вертикальную границу в левом верхнем углу, она автоматически умеет находить ее и в правом нижнем, используя те же самые веса. Это свойство обеспечивает эквивариантность к трансляции.

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

Если наложить это ядро на область изображения с однородным фоном (где все пиксели равны, например, 100), скалярное произведение даст 0 (так как сумма весов ядра равна нулю). Если же ядро попадет на границу, где слева пиксели темные (значение 0), а справа светлые (значение 255), результат будет сильно положительным. Математически это эквивалентно вычислению дискретной производной по оси X. Нейронная сеть не использует готовые фильтры Собеля, она инициализирует матрицу случайными числами и с помощью градиентного спуска находит те значения, которые извлекают наиболее полезные для итоговой функции потерь паттерны.

!Анимация скользящего окна свертки и вычисления скалярного произведения

При работе с многоканальными тензорами (например, RGB-изображение, где количество входных каналов ) ядро становится трехмерным: . Свертка суммирует результаты скалярных произведений по всем входным каналам, выдавая один двумерный срез. Чтобы получить выходных каналов, слой использует независимых трехмерных ядер.

Геометрия тензоров: Padding, Stride и рецептивное поле

Проектирование архитектуры CNN и отладка (debugging) кода требуют строгого контроля за размерностями тензоров. Ошибка несовпадения форм (shape mismatch) — самая частая проблема при сборке графа вычислений. Размер выходной карты признаков для квадратного входа , квадратного ядра , шага окна (stride) и добавленных по краям нулей (padding) вычисляется по формуле:

Где оператор означает округление вниз.

Инженерный нюанс заключается в выборе стратегии padding:

Valid padding (): ядро не выходит за границы изображения. Размерность неизбежно падает с каждым слоем.

Same padding: подбирается так, чтобы при размер выхода был равен входу . Из формулы следует, что . Именно поэтому в глубоком обучении почти всегда используют ядра нечетного размера (, , ), чтобы было целым числом и нули добавлялись симметрично.

Использование шага (strided convolution) является современным стандартом для уменьшения пространственной размерности (downsampling). Исторически для этого применялась операция Max Pooling, однако strided-свертка позволяет сети самостоятельно выучить оптимальный способ агрегации информации при сжатии, вместо жестко заданной выборки максимального элемента.

Важнейшей метрикой сверточной сети является рецептивное поле (Receptive Field, ) — размер области во входном изображении, которая влияет на активацию конкретного нейрона в глубоком слое. Рецептивное поле слоя вычисляется рекурсивно:

Где — рецептивное поле предыдущего слоя, — размер ядра текущего слоя, — шаг свертки на -том слое. Из формулы видно, что для экспоненциального роста рецептивного поля необходимо использовать слои с шагом .

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

Где — исходный размер ядра, а — фактор дилатации (при получаем обычную свертку). Применяя каскад слоев с экспоненциально растущим (например, 1, 2, 4, 8), архитектура способна охватить рецептивное поле в десятки тысяч шагов, сохраняя исходное разрешение сигнала и не увеличивая количество параметров.

!Структура связей при дилатационной свертке

Рекуррентные нейронные сети: проекция времени

Сверточные сети отлично справляются с пространственными данными фиксированного размера, но пасуют перед последовательностями переменной длины (текст, временные ряды, ДНК). Для обработки таких данных применяется рекуррентная нейронная сеть (RNN).

Идея Vanilla RNN заключается во введении скрытого состояния (hidden state), которое служит «памятью» сети. На каждом временном шаге сеть принимает входной вектор и предыдущее состояние , вычисляя новое состояние:

В этой формуле — матрица весов для скрытого состояния, — матрица весов для входного вектора, — вектор смещения, а — нелинейная функция активации, сжимающая значения в диапазон для предотвращения неконтролируемого роста значений активаций.

Ключевой математический нюанс здесь — матрицы весов и идентичны для любого момента времени . Это разделение параметров во времени позволяет модели обрабатывать последовательности любой длины и обобщать паттерны независимо от того, в начале или в конце строки они появились.

Backpropagation Through Time и парадокс длинных цепочек

Обучение RNN осуществляется алгоритмом Backpropagation Through Time (BPTT). Вычислительный граф сети «разворачивается» во времени на длину последовательности . Функция потерь обычно суммируется по всем шагам. Чтобы обновить матрицу , необходимо вычислить градиент .

Согласно цепному правилу, влияние ошибки с шага на состояние шага требует вычисления производной , которая раскладывается в произведение матриц Якоби:

Рассмотрим производную одного шага. Поскольку , матрица Якоби (матрица всех частных производных вектор-функции) равна:

Где — транспонированная матрица весов, — преактивация (аргумент функции ), а — диагональная матрица производных гиперболического тангенса.

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

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

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

LSTM: инженерное решение математической проблемы

Математическая причина затухания градиента в RNN — многократное матричное умножение на при обратном проходе. В 1997 году Сепп Хохрайтер и Юрген Шмидхубер предложили архитектуру Long Short-Term Memory (LSTM), которая заменила мультипликативное обновление памяти на аддитивное.

В LSTM вводится состояние ячейки (cell state) — магистраль, проходящая через всю цепочку времени. Информация добавляется в нее или удаляется с помощью механизмов, называемых вентилями (gates). Вентили — это слои с активацией сигмоиды , выдающие векторы в диапазоне от 0 до 1.

Работа ячейки описывается следующими уравнениями. Сначала вентиль забывания (forget gate) решает, какую информацию из прошлой памяти нужно стереть:

> Инженерный нюанс: При инициализации весов LSTM крайне важно задать вектор смещения вентиля забывания равным 1 (или небольшому положительному числу). Это гарантирует, что в начале обучения , и ячейка пропускает градиенты сквозь время, не обнуляя память до того, как сеть научится извлекать полезные признаки.

Затем входной вентиль (input gate) и слой кандидатов определяют, какие новые данные нужно записать:

Ключевой момент LSTM — обновление состояния ячейки. Оно происходит через поэлементное умножение (произведение Адамара) и сложение:

Посмотрим на производную для обратного распространения. В отличие от Vanilla RNN, здесь она равна . Если сеть решает сохранить память и устанавливает , градиент протекает через ячейку без изменений, не затухая и не взрываясь. Это называется каруселью постоянной ошибки (Constant Error Carousel).

Наконец, выходной вентиль фильтрует состояние ячейки, чтобы сформировать скрытое состояние , которое уходит на следующий шаг и на выход слоя:

Более легкой альтернативой LSTM является GRU (Gated Recurrent Unit), где вентили забывания и входа объединены в один вентиль обновления, а отдельное состояние ячейки отсутствует. GRU требует меньше параметров и вычисляется быстрее, но на сверхдлинных последовательностях LSTM часто показывает большую стабильность.

!Сравнение потока градиента в развернутой RNN и LSTM

Инженерный выбор: 1D-свертки против рекуррентных сетей

При проектировании архитектуры для обработки последовательностей (анализ логов, временные ряды, текст) ML-инженер должен сделать выбор между рекуррентными сетями и одномерными свертками (1D CNN).

| Характеристика | 1D CNN | RNN (LSTM / GRU) | | :--- | :--- | :--- | | Параллелизм | Высокий. Активации для всех окон вычисляются одновременно на GPU. | Низкий. Шаг вычисляется строго после шага . | | Рецептивное поле | Фиксированное (определяется размером ядра, шагом и дилатацией). | Теоретически бесконечное (ограничено затуханием градиента и емкостью памяти). | | Удержание состояния | Нет. Одинаковые паттерны обрабатываются одинаково вне зависимости от контекста далеко в прошлом. | Да. Сеть работает как машина состояний (state machine). | | Применение | Выявление локальных паттернов (морфология слов, высокочастотные аномалии датчиков). | Сложная логика с запоминанием событий (языковое моделирование, машинный перевод). |

Для временных рядов, где нельзя заглядывать в будущее (например, алгоритмическая торговля), применяются причинно-следственные свертки (causal convolutions). В них padding добавляется только слева от текущего временного шага, гарантируя, что выход зависит только от .

Переход от полносвязных сетей к сверточным и рекуррентным архитектурам демонстрирует фундаментальный принцип проектирования ML-систем: структура данных должна диктовать структуру вычислений. Встраивание пространственной инвариантности через скользящее ядро и временной зависимости через рекуррентные связи позволяет радикально сократить пространство поиска параметров и сделать оптимизацию вычислительно осуществимой.

Рекомендуемые ресурсы для глубокого изучения

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

Фундаментальная математика и теория:

Ian Goodfellow, Yoshua Bengio, Aaron Courville. "Deep Learning" (MIT Press). — Библия глубокого обучения. Глава 9 подробно разбирает математику сверточных сетей, а Глава 10 — рекуррентных архитектур и BPTT.

Christopher Bishop. "Pattern Recognition and Machine Learning". — Классический труд для понимания математической статистики и байесовского вывода, лежащих в основе ML.

Инженерная практика и архитектуры:

Dive into Deep Learning (d2l.ai). — Интерактивный учебник, где математический вывод каждой формулы сопровождается реализацией на PyTorch с нуля (без использования nn.Conv2d или nn.LSTM под капотом).

Aurélien Géron. "Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow". — Отличный ресурс для понимания нюансов отладки градиентов, clipping-а и правильной инициализации весов в production.

Статьи и лекции (на английском языке):

Блог Christopher Olah (colah.github.io). — Статья "Understanding LSTM Networks" является золотым стандартом визуального и математического объяснения работы вентилей.

Andrej Karpathy. Лекции курса Stanford CS231n (Convolutional Neural Networks for Visual Recognition). — Обязательно к просмотру для понимания геометрии тензоров, receptive field и backpropagation на уровне матричных вычислений. Также его эссе "The Unreasonable Effectiveness of Recurrent Neural Networks".

Stanford CS224n (Natural Language Processing with Deep Learning). — Глубокий разбор RNN, BPTT и проблемы исчезающего градиента в контексте языковых моделей.

Рекуррентные нейронные сети (RNN) обрабатывают последовательности за время , где — длина последовательности. Чтобы вычислить скрытое состояние для сотого токена, необходимо последовательно дождаться вычисления предыдущих девяноста девяти. Это фундаментальное ограничение делает невозможным эффективное распараллеливание на современных GPU, архитектура которых создана для одновременного выполнения тысяч независимых операций. Трансформеры, представленные в 2017 году, предложили радикальный обмен: сократить время последовательных вычислений до , пожертвовав вычислительной сложностью по памяти, которая возросла до . Этот архитектурный сдвиг позволил утилизировать мощности ускорителей на 100% и стал основой всех современных больших языковых моделей (LLM).

Математика Self-Attention: Запросы, Ключи и Значения

В основе архитектуры лежит механизм внутреннего внимания (Self-Attention). Его задача — для каждого элемента входной последовательности вычислить векторное представление, которое учитывает контекст всей остальной последовательности.

Концепция опирается на парадигму информационного поиска: существует набор ключей (Keys) и связанных с ними значений (Values). Когда поступает запрос (Query), система вычисляет меру сходства между запросом и каждым ключом, чтобы определить, с каким весом взять каждое значение. В механизме Self-Attention все три компонента — Запросы , Ключи и Значения — получаются из одной и той же входной матрицы путем умножения на обучаемые матрицы весов:

Где:

— матрица входных эмбеддингов размерности . — длина последовательности (например, 512 токенов), — размерность скрытого пространства (например, 768).

— обучаемые матрицы весов размерности .

— обучаемая матрица весов размерности .

Результирующие матрицы получают размерность , а матрица — размерность . На практике для симметрии часто задают .

!Схема процесса вычисления механизма внимания (Attention) в архитектуре трансформера.

Основная формула вычисления внимания:

С точки зрения линейной алгебры и аудита размерностей тензоров этот процесс разбивается на четыре этапа:

Матричное умножение : Матрица размера умножается на транспонированную матрицу размера . Результат — квадратная матрица размерности . Это матрица «сырых» оценок внимания (attention scores). Элемент в строке и столбце показывает ненормализованное скалярное произведение (сходство) между -м токеном-запросом и -м токеном-ключом.

Масштабирование на : Деление каждого элемента матрицы на константу. Это критический математический нюанс, предотвращающий затухание градиентов (vanishing gradients).

Применение Softmax: Функция Softmax применяется независимо к каждой строке матрицы . Она переводит сырые оценки в вероятностное распределение. Сумма элементов в каждой строке становится строго равна 1.

Умножение на : Матрица вероятностей умножается на матрицу значений размера . Результат имеет размерность . Каждый вектор в итоговой матрице — это взвешенная сумма векторов значений.

Проблема дисперсии и затухания градиентов

На технических интервью для ML-инженеров часто просят математически обосновать наличие делителя .

Представим, что компоненты векторов и (строки матриц и ) инициализированы так, что являются независимыми случайными величинами с математическим ожиданием и дисперсией .

Скалярное произведение двух таких векторов длины равно . Вычислим математическое ожидание и дисперсию этого произведения. Математическое ожидание: . Дисперсия суммы независимых величин равна сумме их дисперсий: .

Если размерность ключа , дисперсия скалярного произведения становится равной , а стандартное отклонение . Согласно правилу трех сигм, значения в матрице могут легко достигать или .

При подаче таких экстремальных значений в функцию Softmax (), экспонента от наибольшего значения доминирует. Функция распределяет почти 100% вероятности на один элемент (например, ), а остальные получают значения, близкие к нулю.

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

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

Multi-Head Attention: Инженерная реализация и тензорная магия

Один механизм внимания способен сфокусироваться лишь на одном аспекте взаимосвязей между токенами. В естественном языке одно слово может одновременно зависеть от подлежащего (грамматическая связь), от прилагательного (смысловая окраска) и от слова из предыдущего предложения (контекст). Чтобы модель могла параллельно формировать несколько независимых представлений (subspaces), используется Multi-Head Attention (MHA).

!Схема реализации механизма многоголового внимания в архитектуре трансформера.

Вместо одной проекции размерности , входные данные проецируются раз в пространства меньшей размерности . Для каждой «головы» вычисляется свое внимание, затем результаты конкатенируются по последней оси и умножаются на финальную матрицу .

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

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

Вместо матриц весов создается одна объединенная матрица размерности . Входной тензор батча размерности (где — размер батча) умножается на , давая тензор той же размерности .

Далее применяется изменение формы (reshape) и перестановка осей (transpose) — место, где чаще всего возникают ошибки при отладке архитектур:

Тензор преобразуется из в с помощью операции .view(B, N, h, d_k).

Оси переставляются: результат получает форму с помощью .transpose(1, 2).

Размерность батча и количество голов теперь объединены в ведущих измерениях. При матричном умножении на (где имеет размерность ), фреймворк автоматически применяет batched matrix multiplication (bmm). Умножение происходит только по двум последним измерениям , а первые два измерения обрабатываются параллельно. Это позволяет вычислить внимание для всех голов и всех текстов в батче за одну атомарную операцию.

Позиционное кодирование (Positional Encoding)

Поскольку матричные умножения в Self-Attention коммутативны по отношению к перестановке строк, архитектура трансформера по своей природе лишена понимания порядка слов. Матрица просто вычисляет попарные связи. Предложения «Кот съел мышь» и «Мышь съела кот» дадут идентичные наборы выходных векторов, если не внедрить информацию о позиции.

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

Формулы используют синусы и косинусы разных частот:

Где:

— позиция токена в последовательности.

— индекс измерения в векторе (от до ).

!Интерактивная визуализация Positional Encoding: тепловая карта матрицы PE и график вектора для выбранной позиции. Слайдеры позиции и размерности обновляют визуализацию в реальном времени.

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

Из тригонометрии известны формулы сложения углов:

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

> Современные архитектуры (Llama, Mistral) отказываются от абсолютного аддитивного кодирования в пользу роторного позиционного кодирования (RoPE), где информация о позиции внедряется непосредственно на этапе вычисления и через поворот векторов в комплексном пространстве. Это улучшает экстраполяцию модели на длинные тексты.

Архитектура блока: Pre-LN против Post-LN

Каждый слой трансформера состоит из двух основных подслоев: Multi-Head Attention и полносвязной сети прямого распространения (Feed-Forward Network, FFN). Важнейшим архитектурным решением является способ соединения этих блоков с помощью остаточных связей (Residual Connections) и нормализации слоя (Layer Normalization).

Оригинальная архитектура (Post-LN), использованная в BERT, применяет следующий порядок:

Где — это либо MHA, либо FFN. Нормализация применяется после сложения с остаточной связью. При обучении сетей глубже 10-12 слоев конфигурация Post-LN приводит к нестабильности. Прослеживая путь градиента от функции потерь к первым слоям, видно, что градиент на каждом шаге проходит через операцию LayerNorm. Нормализация содержит деление на стандартное отклонение, что математически работает как демпфер, уменьшающий амплитуду градиентов. Это требует сложных схем разогрева скорости обучения (Learning Rate Warmup).

Современные генеративные архитектуры (GPT-3, Llama) используют предварительную нормализацию (Pre-LN):

В конфигурации Pre-LN остаточная связь проходит от начала до конца сети без препятствий. Матрица Якоби для пути через остаточные связи является единичной матрицей. Градиенты от последнего слоя беспрепятственно дотекают до первого, что делает обучение стабильным даже для сетей глубиной в сотни слоев без агрессивного Warmup.

Feed-Forward Network: скрытое расширение размерности

После механизма внимания каждый токен независимо проходит через FFN — двухслойный перцептрон с активацией (обычно ReLU, GELU или SwiGLU) посередине:

Матрица расширяет размерность вектора с (например, 1024) до (обычно , то есть 4096). Матрица сжимает его обратно до .

Механизм внимания отвечает за маршрутизацию информации — он решает, откуда взять данные. FFN отвечает за обработку — он решает, что означают эти данные. Исследования показывают, что расширение до создает пространство признаков, функционирующее как ассоциативная память (Key-Value memory). Матрица (слой ключей) распознает специфические паттерны в векторе токена (например, концепцию «президент Франции»), а матрица (слой значений) формирует выходной отклик (добавляет в вектор информацию «Макрон»).

Авторегрессионная генерация и Causal Mask

При обучении декодера возникает проблема утечки данных (data leakage). Поскольку трансформер обрабатывает всю последовательность параллельно, механизм внимания токена на позиции может «заглянуть» в токены на позициях . Это ломает логику предсказания следующего слова.

Применяется каузальное маскирование (Causal Mask). Перед применением функции Softmax к матрице сырых оценок , к элементам выше главной диагонали (где индекс ключа больше индекса запроса ) прибавляется (в коде используют большое отрицательное число, например ).

Матрица оценок принимает вид:

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

При инференсе (генерации текста) модель предсказывает по одному токену за шаг. Вычислять для всех предыдущих токенов заново на каждом шаге крайне неэффективно (сложность ). Для решения этой проблемы ML-инженеры реализуют KV-cache — кэширование матриц Ключей и Значений для уже вычисленных токенов. На каждом новом шаге вычисляется только для одного нового токена, а его умножается на закэшированные прошлых шагов. Управление памятью KV-cache сегодня является главной задачей при оптимизации инференса LLM.

Ресурсы для глубокого погружения

Для перехода от концептуального понимания к самостоятельному проектированию архитектур и успешному прохождению секций System Design и ML System на интервью, рекомендуется изучить следующие материалы:

Фундаментальная математика и архитектура:

Статья: «Attention Is All You Need» (Vaswani et al., 2017) — обязательна к прочтению в оригинале, включая приложения.

Книга: «Deep Learning» (Ian Goodfellow, Yoshua Bengio, Aaron Courville) — глава по линейной алгебре и оптимизации закроет пробелы в понимании градиентов и матриц Якоби.

Книга: «Dive into Deep Learning» (d2l.ai) — интерактивный учебник с реализацией трансформеров на PyTorch с нуля. Доступен бесплатно онлайн.

Инженерная реализация и отладка (Debugging):

Видеокурс: Andrej Karpathy «Let's build GPT: from scratch, in code, spelled out» (YouTube) — лучший ресурс для понимания размерностей тензоров, .view(), .transpose() и написания кастомного Causal Mask.

Блог: «The Illustrated Transformer» (Jay Alammar) — эталонная визуализация матричных умножений на каждом этапе.

Курс: Stanford CS224N «Natural Language Processing with Deep Learning» — лекции по внутреннему устройству трансформеров и стратегиям Pre-training / Fine-tuning.

Продвинутая оптимизация (на русском языке):

Курс: Материалы Школы анализа данных (ШАД) Яндекса по NLP и глубокому обучению.

Лекции: Видеозаписи тренировок и открытых лекций от исследователей Tinkoff AI и SberDevices на YouTube, где разбираются нюансы KV-cache, RoPE и инференса на GPU.

Fine-tuning и стратегии переноса обучения (Transfer Learning) в прикладных бизнес-задачах

Обучение модели архитектуры ResNet-50 с нуля на датасете ImageNet требует миллионов изображений и дней вычислений на кластере GPU. Обучение современной Large Language Model (LLM) с нуля требует тысяч ускорителей и месяцев непрерывной работы, обходясь бизнесу в миллионы долларов. Однако в реальной инженерной практике задача часто звучит иначе: создать классификатор дефектов на производстве по 500 фотографиям или научить языковую модель отвечать по внутренней базе знаний компании, имея в распоряжении один сервер с видеокартой на 24 ГБ. В таких условиях базовая математика инициализации весов случайным гауссовским шумом терпит крах — многопараметрическая модель мгновенно переобучится на малой выборке, идеально запомнив шум и потеряв обобщающую способность. Единственный математически и инженерно обоснованный путь — перенос обучения (Transfer Learning) и тонкая настройка (Fine-tuning) уже предобученных представлений.

Математическая природа предобученных весов

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

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

Перенос обучения математически сводится к модификации этого графа. Последний слой (или несколько слоев), отвечающий за проекцию скрытых представлений (hidden states) в вероятности исходных классов, отсекается. На его место устанавливается новый слой с весами , инициализированными случайным образом.

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

Динамика градиентов и катастрофическое забывание

Рассмотрим первый шаг оптимизации после замены финального слоя. Ошибка на выходе сети будет огромной, так как матрица генерирует случайные логиты. Согласно цепному правилу дифференцирования (Chain Rule), вектор ошибки , проходящий через сеть от выхода ко входу, будет иметь аномально большую норму.

Обновление весов для любого глубокого слоя на итерации определяется правилом градиентного спуска:

Где:

— матрица весов слоя на текущем шаге.

— скорость обучения (learning rate).

— градиент функции потерь по весам слоя .

Из-за огромного значения градиента на первых итерациях, веса совершат гигантский скачок в пространстве параметров. Матрица навсегда покинет тот полезный, широкий локальный минимум, который был найден при долгом и дорогом предобучении. Модель разрушит свои внутренние универсальные представления еще до того, как новый случайный слой успеет хоть немного адаптироваться к целевой задаче. Этот феномен называется катастрофическим забыванием (catastrophic forgetting).

Инженерные стратегии контроля градиентов

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

Извлечение признаков (Feature Extraction) и заморозка слоев

Самый вычислительно дешевый метод — полная заморозка базовой сети (backbone). Математически это означает принудительное обнуление производных функции потерь по всем параметрам, кроме нового слоя:

В фреймворке PyTorch это реализуется отключением флага requires_grad = False для параметров базовой сети. С точки зрения графа вычислений, обратный проход (backward pass) просто останавливается перед замороженными слоями.

Это дает колоссальный выигрыш в потреблении видеопамяти (VRAM). При стандартном обучении фреймворк обязан кэшировать матрицы активаций прямого прохода для каждого слоя, чтобы позже использовать их в цепном правиле при вычислении градиентов. Заморозка освобождает эту память, что позволяет кратно увеличить размер батча (batch size) и стабилизировать оценку градиента на зашумленных данных.

Ограничение подхода кроется в линейной разделимости: если целевой домен сильно отличается от исходного (например, рентгеновские снимки вместо фотографий из ImageNet), универсальных признаков замороженной сети будет недостаточно для построения корректной разделяющей гиперплоскости новым линейным слоем.

Постепенная разморозка (Gradual Unfreezing)

Вместо одновременного обучения всей архитектуры, процесс разбивается на фазы. Сначала оптимизируется только при полностью замороженном backbone. Когда матрица сходится (ошибка падает, норма градиентов стабилизируется), снимается заморозка со следующего с конца блока слоев. Обучение продолжается с существенно меньшим шагом .

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

Layer-wise Learning Rate Decay (LLRD)

Более элегантный математический подход, ставший стандартом де-факто при тонкой настройке глубоких трансформеров (например, BERT, RoBERTa или семейство LLaMA), — это послойное экспоненциальное затухание скорости обучения.

Идея заключается в отказе от глобального скаляра . Каждому слою присваивается собственный шаг оптимизации . Чем ближе слой ко входу (где хранятся базовые, фундаментальные признаки, требующие максимальной сохранности), тем меньше шаг обновления.

Формула вычисления шага для слоя (LLRD):

Где:

— базовая скорость обучения, применяемая к самому верхнему (новому) слою.

— общее количество слоев в архитектуре.

— индекс текущего слоя (от до , где — первый слой после входа).

— коэффициент затухания (decay factor), гиперпараметр, обычно лежащий в диапазоне .

!Интерактивная визуализация Layer-wise Learning Rate Decay: столбчатая диаграмма показывает, как скорость обучения убывает от последних слоёв к первым при изменении коэффициента затухания λ и базового LR.

Анализ формулы показывает: если сеть состоит из 12 слоев, а , то первый слой будет обновляться с шагом . Это позволяет алгоритму оптимизации гибко адаптировать высокоуровневые концепции на последних слоях, внося лишь микроскопические корректировки в фундаментальные детекторы признаков в начале сети.

Узкое горлышко памяти и Parameter-Efficient Fine-Tuning (PEFT)

С переходом индустрии к большим языковым моделям классический full fine-tuning столкнулся с непреодолимым аппаратным барьером. Рассмотрим точную математику потребления памяти оптимизатором AdamW при обучении модели на 7 миллиардов параметров (например, Mistral 7B).

В режиме инференса (только прямой проход) веса модели в формате половинной точности bfloat16 занимают около 14 ГБ памяти (). Однако для полноценного обучения с Adam требуются дополнительные тензоры:

Мастер-копия весов в float32 для предотвращения потери точности при малых обновлениях: 28 ГБ.

Градиенты функции потерь в float32: 28 ГБ.

Первое состояние оптимизатора (скользящее среднее градиентов ): 28 ГБ.

Второе состояние оптимизатора (скользящая дисперсия градиентов ): 28 ГБ.

Итого, только для хранения параметров и состояний оптимизатора требуется ГБ VRAM. Сюда необходимо добавить память под кэширование активаций для обратного прохода (еще 20-40 ГБ в зависимости от длины контекста). Это делает невозможным локальное дообучение на потребительских GPU.

Решением стала концепция Parameter-Efficient Fine-Tuning (PEFT), флагманом которой является метод LoRA (Low-Rank Adaptation).

Математический аппарат LoRA

Фундаментальная гипотеза LoRA опирается на теорему о «внутренней размерности» (intrinsic dimension). Исследования показывают, что хотя современные трансформеры имеют матрицы весов огромных размеров, для адаптации к конкретной узкой бизнес-задаче полезные изменения весов лежат в подпространстве очень низкой размерности.

Вместо того чтобы вычислять градиенты и обновлять всю матрицу весов , алгоритм LoRA полностью замораживает . Изменение весов моделируется как произведение двух новых обучаемых матриц низкого ранга:

Где и , а ранг выбирается так, чтобы (обычно ).

Прямой проход (forward pass) через линейный слой с применением LoRA описывается уравнением:

Где:

— выходной вектор слоя.

— входной вектор активаций.

— оригинальная замороженная матрица весов.

— константа масштабирования (scaling factor), гиперпараметр, который помогает сохранять стабильность градиентов при изменении ранга .

!Принцип работы LoRA: дополнение замороженных весов модели обучаемыми матрицами низкого ранга.

Анализ вычислительной эффективности: Рассмотрим адаптацию матрицы проекции query в механизме внимания трансформера с размерностью и .

При полном fine-tuning обновляется параметров.

При использовании LoRA с рангом , обучается матрица размером и матрица размером . Суммарно это параметров.

Количество обучаемых параметров сокращается примерно в 250 раз. Градиенты , и тяжелые состояния оптимизатора Adam вычисляются и хранятся только для этих 65 тысяч параметров. Это снижает потребление памяти с десятков гигабайт до сотен мегабайт, позволяя проводить fine-tuning LLM на одной видеокарте класса RTX 4090 (24 ГБ).

Инициализация матриц в LoRA и динамика градиентов

Критически важным аспектом LoRA, обеспечивающим математическую корректность метода, является стратегия инициализации матриц и . Если заполнить обе матрицы случайным шумом, то на первой же итерации добавит мощный шумовой сигнал к выходам замороженного слоя , спровоцировав нестабильность и рост функции потерь.

Решение в архитектуре LoRA:

Матрица инициализируется случайным гауссовским шумом (или инициализацией Кайминга/Ксавье).

Матрица инициализируется строгими нулями.

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

Интересна динамика обратного прохода на первом шаге. Градиент функции потерь по матрице вычисляется по цепному правилу:

Поскольку , градиент . Матрица не обновляется на первой итерации. Однако градиент по матрице :

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

Слияние весов (Weight Merging) для production-инференса

Мощное инженерное преимущество LoRA проявляется на этапе развертывания модели (deployment). Поскольку операции умножения матриц дистрибутивны, базовые веса и обученные адаптеры можно аналитически сложить до начала вычислений:

В результате вычисляется новая статичная матрица той же размерности , что и оригинальная . При инференсе архитектура графа не усложняется, не добавляется никаких дополнительных операций умножения. Задержка (latency) и пропускная способность (throughput) остаются идентичными базовой модели. Это открывает путь к мульти-тенантной архитектуре: в VRAM сервера держится одна тяжелая базовая модель, а для каждого клиента или бизнес-задачи «на лету» подгружаются и применяются крошечные (по 10-50 МБ) матрицы адаптеров и .

Выбор стратегии в зависимости от бизнес-контекста

Проектирование пайплайна Transfer Learning требует от ML-инженера анализа двух метрик: объема доступной размеченной выборки и степени семантического сходства целевого домена с доменом предобучения.

Домен похож, данных мало. Пример: классификация 20 видов офисной мебели с использованием ResNet, обученного на ImageNet. Оптимальная стратегия — заморозка всего backbone и обучение только линейного классификатора (Linear Probing). Риск переобучения критически высок, поэтому регуляризация (Weight Decay, Dropout) должна быть агрессивной.

Домен похож, данных много. Пример: анализ тональности отзывов на банковские продукты с использованием RuBERT. Оптимальная стратегия — полный fine-tuning с использованием LLRD. Большой объем данных защищает от переобучения, а LLRD сохраняет базовые лингвистические паттерны языка.

Домен отличается, данных много. Пример: сегментация спутниковых снимков (SAR) на базе модели, видевшей только обычные фотографии. Требуется полный fine-tuning, часто с повышенным learning rate для глубоких слоев, так как абстрактные признаки ImageNet (глаза животных, колеса машин) бесполезны для радарной съемки.

Домен отличается, данных мало. Самый сложный инженерный кейс. Пример: извлечение сущностей из специфичных юридических контрактов на базе общей LLM. Полный fine-tuning приведет к мгновенному переобучению (модель выучит наизусть 100 контрактов), а Linear Probing не даст результата из-за отсутствия нужных паттернов в базовых эмбеддингах. Инженерное решение — использование LoRA с малым рангом () в сочетании с жесткой аугментацией текстов и строгим мониторингом валидационного loss для ранней остановки (Early Stopping).

Ресурсы для глубокого изучения

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

Фундаментальная математика и теория оптимизации:

Ian Goodfellow, Yoshua Bengio, Aaron Courville. "Deep Learning" (MIT Press). Глава 8 ("Optimization for Training Deep Models") обязательна для понимания динамики градиентов, работы Adam и ландшафтов функций потерь.

Aston Zhang et al. "Dive into Deep Learning" (d2l.ai). Интерактивный учебник с реализацией математики на PyTorch с нуля. Глава 14 ("Natural Language Processing: Pretraining") детально разбирает механику переноса обучения.

Ключевые научные статьи (Papers):

Hu et al., 2021. "LoRA: Low-Rank Adaptation of Large Language Models". Оригинальная статья, содержащая полный математический вывод метода и доказательства сохранения экспрессивности модели при низком ранге.

Yosinski et al., 2014. "How transferable are features in deep neural networks?". Классический труд, математически доказывающий иерархичность признаков и объясняющий, на каком слое происходит переход от универсальных паттернов к специфичным.

Практика проектирования (Видеолекции и курсы):

Stanford CS224N: Natural Language Processing with Deep Learning. Лекции по архитектуре трансформеров и стратегиям их дообучения. Доступны на YouTube.

Andrej Karpathy: "Let's build GPT: from scratch, in code, spelled out". Практическое видеоруководство по программированию трансформера на уровне тензорных операций, необходимое для понимания того, как именно матрицы LoRA встраиваются в механизм Attention.

Материалы сообщества Open Data Science (ODS.ai). Курс "Deep Learning School" (от МФТИ) — один из лучших русскоязычных ресурсов для разбора математики обратного распространения ошибки и написания собственных циклов обучения на PyTorch.

Перенос обучения — это математически выверенный процесс управления градиентами, матричными проекциями и видеопамятью. Понимание того, как штрафуются веса, как распределяется скорость обучения по глубине вычислительного графа и как низкоранговые аппроксимации спасают состояния оптимизатора, отличает инженера, способного спроектировать production-ready систему, от пользователя готовых API.

Отладка и аудит ML-систем: методология поиска ошибок в коде, весах и данных

В классической разработке программного обеспечения фундаментальная логическая ошибка обычно приводит к немедленному падению приложения с подробной трассировкой стека (stack trace). В машинном обучении код с критическими математическими изъянами может успешно скомпилироваться, запуститься на кластере GPU, утилизировать 100% вычислительных мощностей и методично снижать функцию потерь на протяжении нескольких дней. Модель способна выучить шум, найти лазейку в данных или сойтись к константе, не выдав ни единого предупреждения. Эта специфика делает традиционные методы отладки через print и точки останова (breakpoints) недостаточными. Требуется переход к аудиту состояний — непрерывному мониторингу распределений тензоров, математической проверке пайплайнов и изоляции компонентов.

Стратегия абсолютной изоляции: переобучение на одном батче

Первый и главный шаг при сборке любой новой архитектуры, от простейшего многослойного перцептрона до трансформера, — попытка переобучить модель на микроскопической выборке (обычно один батч из 8–32 примеров). Это фундаментальный модульный тест (unit-test) для нейронной сети, который проверяет базовую связность вычислительного графа и способность оптимизатора обновлять веса в направлении антиградиента.

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

Установить вероятность отключения нейронов в Dropout равной .

Отключить Weight Decay (штраф за норму весов) и любую -регуляризацию.

Зафиксировать seed генераторов псевдослучайных чисел на уровне CPU, GPU и библиотек (NumPy, PyTorch/TensorFlow).

Отключить аугментацию данных, чтобы сеть видела абсолютно идентичные пиксели или токены на каждой эпохе.

Если архитектура реализована корректно, ландшафт функции потерь для одного батча при избыточной емкости сети становится тривиальным. Функция потерь должна стремительно упасть до нуля (или до теоретического минимума для выбранного loss-а, например, энтропии целевого распределения), а метрика качества на этом же батче — достичь 100%. Если этого не происходит, проблема гарантированно лежит в коде, а не в сложности данных, нехватке эпох или неудачном выборе гиперпараметров.

Типичные причины провала этого теста:

Разрыв вычислительного графа. Ошибка, при которой часть тензоров случайно отсоединяется от графа автодифференцирования. Это часто происходит при создании нового тензора через torch.tensor(x) вместо использования дифференцируемых операций над существующим тензором x.clone(). Градиенты до этих узлов не доходят, и часть сети остается со случайными инициализированными весами на протяжении всего обучения.

Асимметрия входов и меток. Батч данных и батч меток перемешиваются независимо друг от друга в загрузчике данных (Data Loader). В результате сеть пытается отобразить изображение кота на метку «автомобиль», что делает задачу неразрешимой даже для одного батча, так как одинаковые признаки начинают соответствовать разным целевым переменным.

Топологические циклы и ошибки размерностей. Использование view() или reshape() вместо transpose() при изменении формы тензоров. Операция reshape просто перекладывает элементы в памяти, что при работе с многоканальными изображениями или многомерными временными рядами полностью разрушает пространственную или временную структуру данных, превращая их в белый шум.

Аудит пайплайна данных: утечки и смещения

Самые дорогие ошибки в ML-системах происходят задолго до того, как данные попадают в тензоры. Утечка данных (Data Leakage) — это ситуация, когда модель во время обучения получает доступ к информации, которая в реальности будет недоступна в момент инференса (применения модели в рабочей среде).

Утечка целевой переменной (Target Leakage)

Математически утечка целевой переменной означает нарушение условия независимости признаков от будущего состояния системы. Пусть — целевая переменная (например, факт дефолта по кредиту), а — вектор признаков. Утечка возникает, когда в включается признак , значения которого формируются в момент времени , где — момент, когда мы должны сделать прогноз.

Классический пример из телекома: предсказание оттока клиентов (churn). Если в качестве одного из признаков используется «дата последнего звонка в техподдержку», а датасет собирался путем выгрузки исторических данных на 31 декабря, то для клиентов, расторгнувших договор в ноябре, эта дата физически не может быть позже ноября. Модель быстро замечает абсолютную корреляцию: если с момента последнего звонка прошло больше 30 дней, вероятность оттока равна 100%. В продакшене такая модель бесполезна, так как для лояльного клиента, который просто не звонил месяц, она выдаст ложный сигнал о неминуемом оттоке.

Другой пример из медицины: предсказание риска тяжелой пневмонии, где одним из признаков выступает «тип больничной койки» (обычная или реанимационная). Пациент попадает в реанимацию вследствие тяжелой пневмонии. Модель выучит, что реанимационная койка — лучший предиктор болезни, но в момент поступления пациента в клинику (когда прогноз действительно нужен) этот признак еще не существует.

!Схема иллюстрирует утечку целевой переменной, когда данные из будущего ошибочно попадают в обучение.

Ошибка нормализации (Train/Test Contamination)

Вторая форма утечки возникает при некорректной стандартизации данных или отборе признаков. Пусть и — выборочное среднее и стандартное отклонение признака. Если эти статистики вычисляются по всему датасету до разделения на обучающую и тестовую выборки, тестовые данные косвенно влияют на обучающие.

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

Разделить данные на обучающую матрицу и тестовую .

Вычислить и строго на .

Применить трансформацию к обеим выборкам.

В противном случае оценка качества на тестовой выборке будет оптимистично смещена. Модель частично «видела» распределение теста через глобальные параметры нормализации. В глубоком обучении это особенно критично при работе с текстами (когда словарь токенов или TF-IDF веса строятся по всему корпусу) и временными рядами (когда скользящие средние захватывают данные из будущего).

Телеметрия тензоров: аудит весов и градиентов

Когда сеть обучается, но сходится слишком медленно, застревает в субоптимуме или внезапно выдает NaN (Not a Number), необходимо внедрить телеметрию — логирование статистик активаций и градиентов на каждом слое.

Распределения активаций (Forward Pass)

Для каждого слоя вычисляются математическое ожидание и дисперсия его активаций . Здоровая глубокая нейронная сеть должна поддерживать дисперсию активаций примерно на одном уровне (около ) на протяжении всех слоев. Это достигается правильной инициализацией весов (например, методом Ксавье или Кайминга).

Математика инициализации Ксавье требует, чтобы дисперсия выходов линейного слоя была равна дисперсии входов. Если , то при условии независимости входов и нулевом среднем весов:

где — количество входов нейрона. Чтобы , дисперсия весов должна быть .

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

!Интерактивная телеметрия активаций 5-слойной нейросети: слайдер масштаба инициализации весов показывает, как распределения активаций затухают, взрываются или остаются стабильными на каждом слое.

Отношение шага к весу (Update-to-Weight Ratio)

Один из самых мощных инструментов аудита процесса оптимизации — отслеживание отношения нормы обновления к норме самих весов. Пусть — матрица весов конкретного слоя, а — шаг обновления, который делает оптимизатор (например, SGD или Adam). Отношение вычисляется как:

где — -норма (евклидова норма) тензора, то есть корень из суммы квадратов всех его элементов.

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

Если или выше, веса меняются слишком агрессивно. Модель «мечется» по ландшафту функции потерь, разрушая ранее выученные полезные паттерны. Решение: снизить Learning Rate или увеличить размер батча.

Если или ниже, веса практически заморожены. Сеть обучается недопустимо медленно. Решение: увеличить Learning Rate, уменьшить регуляризацию или проверить, не затухают ли градиенты на пути к этому слою (Vanishing Gradients).

Скрытые логические ошибки в коде

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

Утечка паддинга в функцию потерь

При обработке последовательностей (тексты, аудио, временные ряды) батч формируется из примеров разной длины. Короткие последовательности дополняются специальным токеном <PAD>, чтобы сформировать прямоугольный тензор фиксированного размера, пригодный для матричного умножения на GPU.

Если вычислять функцию потерь (например, Cross-Entropy) наивно, усредняя ошибку по всему тензору, токены паддинга внесут огромный вклад в общий loss. Сеть начнет тратить свою репрезентативную емкость на то, чтобы идеально предсказывать бессмысленный токен <PAD> на пустых позициях, вместо того чтобы фокусироваться на реальных данных.

Математически корректное вычисление требует использования бинарной маски , где означает реальный токен, а — паддинг. Формула маскированной функции потерь выглядит так:

Здесь — предсказание (вектор логитов) для элемента в батче , — истинная метка, а — функция кросс-энтропии. Знаменатель представляет собой сумму всех единиц в маске, то есть точное количество реальных токенов в батче.

Частая ошибка — деление суммы числителя на константу (общую площадь тензора). Это искусственно занижает градиенты для батчей с большим количеством паддинга (где реальных токенов мало, но ошибка делится на большое число ), делая обучение нестабильным.

Рассинхронизация режимов Train и Eval

Слои вроде Batch Normalization и Dropout ведут себя принципиально по-разному во время обучения и инференса. В PyTorch за переключение графа вычислений отвечает вызов методов model.train() и model.eval().

В режиме обучения Batch Normalization нормализует данные, используя статистики текущего батча. Пусть — активации для -го элемента в батче размера . Слой вычисляет среднее и дисперсию . Одновременно слой обновляет экспоненциальное скользящее среднее (EMA) глобальных статистик и , которые будут использоваться после обучения:

где — коэффициент сохранения (momentum).

В режиме оценки (model.eval()) слой прекращает вычислять статистики по батчу и использует только накопленные глобальные и .

Если проводить валидацию, забыв переключить модель в eval(), произойдет скрытая утечка. Модель нормализует тестовый батч, используя среднее и дисперсию самого этого тестового батча. Это грубо нарушает принцип независимости предсказаний: результат для конкретного объекта начнет зависеть от того, какие еще объекты случайным образом оказались с ним в одном валидационном батче. Метрики качества в таком сценарии будут искусственно завышены, а при поштучном инференсе в продакшене (где размер батча равен 1, и дисперсия одного элемента равна нулю) модель выдаст неадекватные результаты или NaN.

Диагностика по кривым обучения (Loss Curves)

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

!Типичные графики потерь при ошибках в конфигурации и обучении нейронных сетей.

Шумная кривая с высокой амплитудой колебаний. Если loss скачет вверх-вниз на каждом шаге, не показывая четкого тренда к снижению, это признак слишком высокой скорости обучения (Learning Rate) или экстремально малого размера батча. Оптимизатор перепрыгивает через локальные минимумы, не успевая в них спуститься.

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

Расхождение Train и Validation. Классическое переобучение (Overfitting). Обучающий loss продолжает падать, стремясь к нулю, в то время как валидационный loss останавливается, образует U-образную кривую и начинает расти. Модель перестает обобщать фундаментальные паттерны и начинает запоминать шум обучающей выборки.

Слишком близкие кривые Train и Validation. Если валидационный loss почти идеально совпадает с обучающим и оба прекращают снижение на высоком уровне (ошибка остается большой), это признак недообучения (Underfitting). Емкость (capacity) модели слишком мала для данной задачи, архитектура не способна аппроксимировать искомую функцию, либо применена избыточная регуляризация.

Метод абляции (Ablation Studies)

Когда сложная архитектура (например, ансамбль трансформеров с кастомными функциями потерь) показывает результаты хуже ожидаемых, невозможно сразу определить виновника. В таких случаях применяется метод абляции (от лат. ablatio — отнятие) — последовательное удаление или упрощение компонентов системы для оценки их изолированного вклада.

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

Заменить сложный кастомный механизм многоголового внимания на стандартное усреднение признаков (Global Average Pooling).

Убрать все вспомогательные функции потерь (auxiliary losses), оставив только основную кросс-энтропию.

Заменить глубокую сеть на логистическую регрессию поверх предобученных эмбеддингов.

Если упрощенная модель работает лучше или так же, как сложная, это означает, что удаленный компонент был реализован с математической ошибкой или архитектурно несовместим с задачей. Возвращая компоненты строго по одному и замеряя метрики, инженер точно локализует источник деградации. Этот подход защищает от «карго-культа» в ML, когда в архитектуру добавляются модули из последних научных статей без понимания их реального влияния на конкретный домен данных.

Ресурсы для глубокого погружения

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

Книги и учебники:

«Deep Learning» (Ian Goodfellow, Yoshua Bengio, Aaron Courville) — библия глубокого обучения. Глава 8 («Optimization for Training Deep Models») детально разбирает математику инициализации, затухания градиентов и алгоритмов оптимизации.

«Pattern Recognition and Machine Learning» (Christopher Bishop) — фундаментальный труд по байесовскому подходу и математической статистике в ML. Необходим для глубокого понимания природы функций потерь и регуляризации.

«Machine Learning Engineering» (Andriy Burkov) — практическое руководство по созданию надежных ML-систем, включая главы по утечкам данных, правильному сплитованию и мониторингу моделей в продакшене.

Курсы и лекции (YouTube):

Andrej Karpathy: Neural Networks: Zero to Hero — серия видео от бывшего директора по ИИ в Tesla. Идеально покрывает процесс создания нейросетей с нуля на PyTorch, включая отладку размерностей тензоров и визуализацию градиентов.

Stanford CS231n (Convolutional Neural Networks for Visual Recognition) — лекции Стэнфордского университета. Модули по обучению нейросетей (Training Neural Networks I & II) являются золотым стандартом для понимания инициализации, нормализации батчей и настройки гиперпараметров.

Тренировки по ML от ODS (Open Data Science) — русскоязычный ресурс с глубоким разбором классического ML, где подробно разбираются проблемы валидации, утечек данных (target leakage) и построения надежных пайплайнов.

Статьи и гайды:

«A Recipe for Training Neural Networks» (Andrej Karpathy) — классический блог-пост, который формализует подход к отладке нейросетей, начиная с переобучения на одном батче и заканчивая тонкой настройкой регуляризации. Обязателен к прочтению перед запуском первого loss.backward().