Руководство. Линейная регрессия

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

Вызов hcat генерирует объект Matrix, содержащий числа от -3.0 до 3.0 с шагом 0.1. В каждом столбце этой матрицы содержится отдельный x, всего 61 координата x. На следующем шаге следует сгенерировать соответствующие метки (y).

Функция f сопоставляет каждый x с y, а так как координаты x сведены в Matrix, выражение транслирует скалярные значения с помощью макроса @.. Точки данных готовы, но они слишком идеальны. В реальном сценарии функции f для генерирования значений y не было бы. Вместо этого пришлось бы добавлять метки вручную.

Визуализация итоговых данных:

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

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

Модель линейной регрессии математически выражается так:

где W — матрица весов, а b — смещение. В нашем случае матрица весов (W) будет состоять из единственного элемента, так как признак только один. Определить нашу модель в Julia можно в точно такой же форме!

Макрос @. позволяет выполнять вычисления путем трансляции скалярных величин (например, смещения).

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

Пора проверить, работает ли наша модель.

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

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

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

Dense(1 => 1) означает слой с одним нейроном, имеющим один вход (признак) и один выход. Этот слой в точности соответствует определенной выше математической модели. На внутреннем уровне Flux вычисляет выход с использованием того же выражения! Но на этот раз нам не нужно самим инициализировать параметры — Flux сделает это за нас.

Теперь можно проверить, правильно ли работает модель. Мы можем передать сразу все данные, где каждый x имеет ровно один признак (вход):

Работает! Следующий шаг — определение функции потерь с помощью функций Flux:

Все работает, как и прежде! Похоже на то, будто Flux предоставляет нам эффективные оболочки для функций, которые иначе пришлось бы писать самим. Наконец, в качестве последнего шага в этом разделе, давайте посмотрим, насколько flux_model отличается от custom_model. Для этого неплохо будет задать фиксированные одинаковые значения для параметров обеих моделей. Давайте изменим параметры custom_model так, чтобы они соответствовали параметрам flux_model:

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

Потери одинаковые! Это означает, что наши модели model и flux_model в какой-то степени равносильны и функции потерь полностью идентичны! Различие между моделями состоит в том, что слой Dense во Flux поддерживает множество других аргументов, с помощью которых его можно настроить дополнительно. Но в рамках данного руководства давайте ограничимся нашей простой моделью custom_model.

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

Здесь W — матрица весов, b — вектор смещений,  — скорость обучения,  — производная функции потерь относительно веса, а  — производная функции потерь относительно смещения.

Производные вычисляются с помощью инструмента автоматического дифференцирования. Во Flux для этой цели применяется Zygote.jl. Так как Zygote.jl — это автономный пакет Julia, его можно использовать и без Flux. Дополнительные сведения см. в документации по Zygote.jl.

В первую очередь следует получить градиент функции потерь относительно весов и смещений. Flux повторно экспортирует функцию gradient из Zygote, поэтому импортировать Zygote явным образом для ее использования не требуется.

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

Параметры обновлены. Теперь можно проверить значение функции потерь:

Потери уменьшились! Это значит, что мы успешно обучили модель за одну эпоху. Мы можем ввести написанный выше код обучения в цикл и обучить модель в течение большего числа эпох. Можно настроить фиксированное количество эпох либо остановку при соблюдении какого-либо условия, например change in loss < 0.1. Цикл можно адаптировать под потребности пользователя, а условия указывать в виде обычного кода Julia.

Давайте включим логику обучения в функцию и повторим тестирование:

Модель работает, а потери уменьшились еще больше! Это была вторая эпоха процесса обучения. Давайте добавим логику в цикл for и обучим модель в течение 30 эпох.

Потери существенно снизились, и параметры обновились.

Можно обучать модель дольше или подобрать гиперпараметры так, чтобы нужный результат достигался быстрее, но давайте остановимся на этом. Мы обучали модель в течение 42 эпох, и потери снизились с 22.74856 до 7.6680417f. Пора приступать к визуализации.

Главной целью этого руководства было построить линию по точкам из набора данных с помощью алгоритма линейной регрессии. Обучение прошло успешно, и потери существенно уменьшились. Давайте посмотрим, как выглядит построенная линия. Напомним, что Wx + b — это попросту уравнение прямой, где slope = W[1], а y-intercept = b[1] (с индексацией от 1, так как W и b — итерируемые объекты).

Построим прямую и точки данных с помощью Plot.jl:

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

Сначала инициализируем набор данных. Мы будем использовать набор данных BostonHousing, состоящий из 506 точек данных. У каждой из этих точек 13 признаков и соответствующая метка — цена дома. Каждая координата x по-прежнему сопоставлена с единственной меткой y, но теперь у одного x 13 признаков.

Теперь можно разделить полученные данные на обучающий и проверочный наборы:

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

Данные действительно не нормализованы. Нормализовать обучающие данные можно с помощью функции Flux.normalise.

Теперь среднеквадратичное отклонение близко к единице. Данные готовы!

Теперь можно напрямую воспользоваться пакетом Flux, чтобы переложить на него всю работу! Давайте определим модель, которая принимает 13 входов (признаков) и выдает один выход (метку). Затем мы пропустим через эту модель сразу все данные, и обо всем позаботится Flux! Напомним, что модель можно было бы объявить и в виде обычного кода Julia. У модели будет 14 параметров: 13 весов и 1 смещение.

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

Теперь можно перейти к этапу обучения.

Для процесса обучения будет использоваться та же математическая логика, но теперь можно передать модель в вызове gradient и доверить вычисление производных Flux и Zygote!

В отличие от предыдущей процедуры обучения, на этот раз мы решаем, что не хотим задавать фиксированное количество эпох в коде. Мы хотим, чтобы обучение прекращалось при сходимости потерь, то есть когда change in loss < δ. Величину δ можно изменять так, как нужно пользователю, но в данном руководстве давайте зададим ее равной 10⁻³.

Такие пользовательские циклы обучения можно легко создавать с помощью Flux и обычного кода Julia!

Сначала в коде инициализируется начальное значение потерь: infinity. Затем выполняется бесконечный цикл, который прерывается при change in loss < 10⁻³. Если это условие не выполняется, то значение loss_init изменяется на величину текущих потерь и начинается следующая итерация.

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

Давайте посмотрим на потери:

Потери существенно уменьшились! Их можно снизить еще больше, выбрав еще меньшее значение δ.

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

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

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

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

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