Ранее мы обсуждали с вами RoPE, а теперь поговорим о его модификациях. Собрали много интересного, поэтому будет целых три поста по этой теме. Enjoy!

Для начала напомним, что Positional Encoding (кодирование позиций слов/токенов) нужен, чтобы передать модели или трансформеру информацию о позициях слов — относительную или же абсолютную.

Как развивалось позиционное кодирование:

📆 2017 год
С появлением ванильного трансформера позиции токенов кодировались тригонометрической функцией, значение которой зависело от позиции и просто прибавлялось к эмбеддингу соответсутвующего слова.

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

Минусы — не очень работает на длинных последовательностях, да и вообще не очень хорошо работает.

📆 2018 год
Потом появился гугловский BERT, а вместе с ним новый подход позиционного кодирования: авторы предложиди выкинуть тригонометрию и вместо этого добавить в модель ещё один обучаемый слой nn.Embedding — такой же, как для получения эмбеддингов слов. Он должен кодировать — то есть, превращать в вектор — позицию токена.

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

В это же время впервые появилась идея о том, что нам важны не столько абсолютные позиции слов, сколько относительные. Авторы статьи решили кодировать не абсолютную позицию, а только относительную (Relative Position Encoding, или RPE), то есть близость каждой пары токенов. Здесь же появилась идея, что позицонное кодирование стоит добавлять не в момент создания эмбеддингов слов, а на этапе Attention, добавляя знание о позициии в queries и keys.

Продолжаем рассказывать про развитие позиционного кодирования — предыдущий пост выше ⬆️

📆 2021 год
Тут появился RoPE — великий и ужасный убийца остальных методов позионного кодирования. Он унаследовал от предшественников всё лучшее: из ванильного трансформера — идею, что тригонометрия хороша для кодирования позиции, а из RPE — что проворачивать всё это кодирование надо на этапе аттеншена, и не забывать про важнность относительных позиций. В итоге, RoPE реализует и абсолютное, и относительное кодирвоание одновременно.

В это же время зародилась идея о том, что хорошо бы нам уметь работать на инфренсе на текстах, которые превосходят длиной те, которые модель видела на этапе обучения, так как учить модель на длинных текстах изначально нереально из-за нехватки памяти. Предлагается Attention with Linear Biases (ALiBi) — метод позицонного кодирования, который учитывает только лишь относительные позиции слов, которые не выучиваются, а являются статичными. Перед софтмаксом в Attention мы прибавляем значение растяния между токенами, домноженное на некоторый коэффициент, который является гиперпараметром.

В это же время начали активно развиваться LLM-ки, в том числе опенсорсные. И вот, с появлением LLAMA в 2023 году разработчики по всему миру получили возможность руками поработать с LLM-кой и что-то в ней докрутить под себя. Благодаря этому следующая веха развития позиционок началась, внезапно, на Reddit.

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

📆 2023 год
Пользователь Reddit размещает пост о том, что если чуть уменшить основание RoPE-аттеншна, то модель будет отлично работать на текстах длиннее, чем те, на которых она училась. Такой подход называет NTK-Aware Scaled RoPE.

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

Спустя пару недель после реддитовского NTK уже на ACL, большой и уважаемой конференции, появляется xPos: Extrapolatable Position Embedding. Идея тут схожая: мы хотим уметь экстраполироваться на более длинные тексты. Авторы пытаются решить следующую проблему: функция поворота в RoPE не монотонна, так как её монотонность нарушается для углов больше 180 градусов, и поэтому плохо экстраполируется. Решают в статье эту проблему так: уже после домножения queries и keys на матрицы поворота мы так же домножаем их на матрицу «смягчения», которая чуть замедляет вращение и не даёт нам получать углы больше 180 градусов. Так функция получается монотонной, благодяря чему дальние позиции кодируются немного лучше.

Ещё спустя месяц после xPos появился YaRN, или Yet another RoPE extensioN method. Идея у него примерно такая же, как и у предыдущих: давайте перед софтмаксом будем умножать произведение наших queries и keys на некий коэффициент (или scale factor), просто сам этот scale factor считать будем немного по-другому.

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

Вспоминаем основы работы с временными рядами

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

Прежде всего вспоминаем, что временной ряд состоит из:

📌 Тренда — долгосрочного роста или спада.
📌 Cезонности — повторяющихся паттернов.
📌 Всего остального (по классике «шум»).

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

Разберёмся по порядку!

Тренд

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

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

Зачем это нужно?

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

Сезонность

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

Сезонность в данных — это регулярные повторения, например:

🗓 Недельная: люди больше слушают музыку по пятницам в день выхода новых релизов на стримингах.
📆 Месячная: рост переводов и покупок в дни выдачи зарплаты.
📆 Годовая: рост покупок фитнес-абонементов в начале нового года.

Тот же STL, помимо тренда, автоматически выдаёт и сезонную компоненту.

Для выделения отдельных сезонностей подходит:

📌 Автокорреляция — помогает увидеть, через какие интервалы значения ряда повторяются.
📌 Периодограмма — её пики подсветят наиболее сильные сезонности.

Зачем это нужно?

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

Кстати, для анализа и прогнозирования временных рядов есть удобный Python-фреймворк etna. Он позволяет легко применять трансформации к ряду, строить прогнозы и тестировать модели — мы в Точке активно его используем. Для тех, кто работает с time-series и любит sklearn-api, но ещё не пробовал etna – рекомендуем.

Линк на туториалы 🌋

Как упростить оптимизацию гиперпараметров?

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

- Параметр λ в L2 или L1 регуляризации.
- Число соседей в kNN.
- Количество слоёв в нейронных сетях.

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

Что мы хотим в идеале? Чтобы человек вообще не принимал участие в подборе гиперпараметров. Для этого нужно:

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

Один из гиперпараметров — это learning rate, который используют в градиентной оптимизации, в частности — в градиентном спуске. Но есть ситуации, когда можно обойтись без него и при этом получить оптимальное качество. Например, в линейной регрессии:

||Xw-Y||^2 + λ||w||^2

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

xₜ₊₁ = xₜ - η ∇ f(xₜ),
где η — это размер шага (stepsize)

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

Не забывайте про поведение градиента. Если функция меняется медленно, то шаг должен быть больше, и наоборот. За это отвечает специальная константа, которая называется константой Липшица. Функция f называется G-Липшицевой, если для любых двух точек Х и Y выполнено неравенство G ≥ ||f(x) - f(y)|| / ||x-y||

Таким образом, величина оптимального шага в градиентном спуске зависит от:

- Расстояния до решения — если возьмем точку подальше, можем не сойтись.
- Константы Липшица — если не учтём, будем сходиться очень медленно.

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

Как оценить оптимальный шаг при градиентном спуске?

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

Вот один из способов, как можно их оценить:

📌 Приближаем константу Липшица

Константа Липшица очень напоминает норму градиента. Возьмём её как среднее квадратичное этой нормы за T итераций.

📌 Оцениваем расстояние до оптимума

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

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

📌 Используем итеративный подход:

1. Выполняем несколько итераций градиентного спуска с произвольным шагом и собираем статистику для оценки G и расстояния до оптимума: k=2,4,8,16…

2. Задаём общее число подсчётов градиента: T_k ← [B / (2k)]

3. Допустим, у нас есть функция, которая по собранным статистикам возвращает некоторый шаг. Назовём её Root Finding Bisection. Если собранные статистики оказались достаточно хорошими, она вернёт нам близкий к оптимальному шаг, и по нему мы уже окончательно спустимся.

Формулу прикрепим в следующем посте картинкой ⬇️

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

Подробнее про создание parameter-free SGD можно почитать тут.

Функция Root Finding Bisection

Что такое Root Finding Bisection?

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

Мы определяем минимальный и максимальный шаг и постепенно сужаем диапазон, а именно:

📌 Определяем количество итераций T, которые мы будем выполнять.

📌 Задаём нижнюю и верхнюю границы шагов (η_lo и η_hi).

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

Процесс можно представить как модификацию бинарного поиска:

📝 У нас есть отрезок [A, B], в котором предположительно находится корень функции. При этом A — это нижняя граница, B — верхняя.

📝 На каждом шаге вместо среднего арифметического берём среднее геометрическое:
√(A × B).

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

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

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

Геометрическое среднее между границами η_lo и η_hi

Обычно в этом канале мы постим обзоры инструментов и объясняем что-то прикладное. Но сегодня решили показать, в чём главный приницип Точки и нашей ML-команды — для этого есть отличный повод.

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

Хотим показать вам новый ролик, который хорошо отражает наше отношение к работе. Приходите к нам, если хотите так же ⬇️

В следующих постах будем больше говорить о наших ежедевных задачах и проектах 💜

Что такое Bias и Variance?

Bias (смещение) — ошибка, которая возникает из-за недостаточной сложности модели.

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

Таким образом, у нас может быть три типа моделей:

📝 Недообученная: слишком простая, имеет высокий bias и низкий variance.
📝 Переобученная: слишком сложная, имеет низкий bias и высокий variance.
📝 Оптимальная: имеет идеальный баланс между смещением и дисперсией.

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

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

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

Почему же такого нет у больших моделей типа GPT?

Потому что у этого графика есть продолжение. Когда количество параметров модели увеличивается тестовая loss делает спуск. Это называется double descent:

📝 Complexity double descent — когда мы наращиваем сложность модели;
📝 Data double descent — когда мы увеличиваем объём обучающей выборки при фиксированной сложности модели.

Благодаря этому феномену более сложные большие модели могут находить более простые решения.

Почему большие модели устойчивы?

Предыдущий пост закончили на том, что у более сложных моделей типа GPT есть double descent. Продолжаем тему — начнём с того, как оценить сложность модели с помощью константы Липшица:

f(x_1) - f(x_2)| ≤ L × |x_1 - x_2|

Это мера «резкости» функции: чем больше производная на определенном интервале, тем больше флуктуации — константа Липшица указывает на их силу.

Посчитать её можно по производной на отрезке: формулу прикрепим к следующему посту.

Вы, наверняка, замечали, что чем больше коэффициенты у модели, тем сильнее её «штормит». У больших моделей это напрямую связано с константой Липшица:

📎 Возьмём фиксированную модель с K параметров и train loss=0

f_1(x) = f1 (x_0, x_1,..., x_k), x, x’ ∈ R_k

Её константа Липшица будет равна L_1.

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

f_2(x, x_k+1) = f2 (x_0, x_1,..., x_k, x_k+1), x, x’ ∈ R_k

Её константа Липшица будет равна L_2.

📎 Оптимизация: обучим новую нейронную сеть так, чтобы L_2 ≤ L_1

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

Как посчитать константу Липшица по производной на отрезке

Что такое grokking?

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

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

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

Этот эффект называется grokking. Термин заимствовали из книги Роберта Хайнлайна «Странный новый мир», где автор описывал концепцию полного понимания чего-либо. Модель продолжает учиться на данных даже после того, как достигла нулевой ошибки на тренировочном наборе.

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

📝 Full batch — практически никогда не достигает стопроцентного качества.
📝 Mini batch — показывает более качественный результат.
📝 Mini batch с включённым Weight decay — лучше всего демонстрирует генерализацию на данных.

Подробнее про Weight decay расскажем в следующем посте.

Что такое Weight decay?

Это продолжение поста про Grokking.

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

Представьте точку в пространстве и два вектора: один направлен на loss, a второй — на Weight decay. Когда ошибка нулевая, компоненты Weight decay становятся ведущими. Если мы случайно отклонимся от точки с ненулевым train loss, Weight decay поможет вернуть нас обратно.

Что за узкий минимум?

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

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

📌 Dropout: случайное отключение нейронов во время обучения.
📌 Weight decay: штраф за большие веса.
📌 Шум к градиенту: случайные колебания или вариации в оценке градиента функции потерь.

ML-team Точки на DUMP

Завтра наш DS Сева Богодист расскажет, как эффективно анализировать текстовое содержание сайтов без необходимости большого объёма размеченных данных. Поговорим о различных подходах и том, как при помощи ансамбля из слабых моделей, которые решают отдельные задачи, достигнуть значимого эффекта.

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

Так что, если вы в Екатеринбурге, приходите!

Как обучать модели, если данных мало

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

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

Как обучать модели с минимумом разметки:

📌 Active Learning — модель сама выбирает примеры для разметки, которые дадут наибольший прирост качества.
📌 Semi-Supervised Learning — используем небольшое число размеченных данных вместе с неразмеченными, например, через псевдоразметку.
📌 Transfer Learning — переносим знания с одной задачи на другую, что помогает значительно сократить потребность в разметке.

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

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

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

Programmatic Weak Supervision (PWS): объединяем слабые источники

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

Как это работает?

Допустим, мы решаем задачу классификации текстов. Для этого мы:

📌 Читаем тексты и привлекаем экспертов, чтобы сформулировать эвристики и регулярные выражения.

📌 Оформляем их в виде разметочных функций, которые автоматически назначают метки.

📌 Тестируем и дорабатываем разметочные функции на небольшой dev-выборке.

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

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

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

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

Среди популярных библиотек для weak supervision — Snorkel, которая реализует PWS и гибко комбинирует слабые источники разметки.

LLM можно использовать как дополнительный источник слабых меток. Например:

📝 Заменять ключевые слова и эвристики вопросами к тексту на естественном языке.
📝 Генерировать эвристики для автоматической разметки.
📝 Комбинировать LLM с традиционными методами weak supervision, чтобы улучшать итоговое качество разметки.

Исследования показывают, что PWS + LLM уже опережает few-shot и zero-shot подходы по качеству!

📢 Подробнее о weak supervision и о том, как мы применяем его в Точке — в следующих постах. А пока можете почитать хороший обзор на тему обучения со слабым контролем.

💜 Этот пост написал Артур Сосновиков, тимлид нескольких ML-команд в Точке.

Это не реклама — мы зовём вас на PyCon от чистого сердца 💜

В этом году в программном комитете в Data-треке от Точки будут драйверы этого канала — Head of ML Андрей Румянцев и лид ML-комьюнити Слава Баженов.

Если вам есть, что рассказать сообществу — скорее подавайте заявку! Форматы разные:

📢 Классические доклады на 30–40 минут.
📢 Мастер-классы — для тех, кто готов провести обучение для группы.

Не знаете, о чём рассказать? Загляните в список идей — может, какая-то из них вдохновит.

Подавайте заявки до 12 мая → https://pycon.ru/cfp

До встречи на сцене (или в зале)!

👾 Выходим с праздников с постом о математике — насколько глубоко нужно в неё погружаться для комфортной работы?

Многие начинающие Data Scientists задаются вопросом: «Хватит ли мне знаний математики в объёме первого курса матанализа и линейной алгебры?». Кажется, что для понимания классических методов и базовых нейронных сетей достаточно уметь перемножать матрицы и брать производные.

Но неужели этого достаточно для большинства задач машинного обучения?

Наш ответ — однозначно нет! Перечислим несколько математических дисциплин, приложения которых используются в Точке на практике:

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

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

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

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

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

💜 Этот пост написал Сергей Станко, ML-инженер в Точке.