Линейная регрессия в Python

3 мая, 2020

Подписывайся на наш канал в Telegram, чтобы ежедневно совершенствоваться в Python - перейти

Перевод статьи

Оглавление

  • Регрессия
    • Что такое регрессия?
    • Когда вам нужен регресс?
  • Линейная регрессия
    • Постановка проблемы
    • Производительность регрессии
    • Простая линейная регрессия
    • Множественная линейная регрессия
    • Полиномиальная регрессия
    • Подгонка и переоснащение
  • Реализация линейной регрессии в Python
    • Пакеты Python для линейной регрессии
    • Простая линейная регрессия с scikit-learn
    • Множественная линейная регрессия с scikit-learn
    • Полиномиальная регрессия с scikit-Learn
    • Продвинутая линейная регрессия со statsmodels
  • За пределами линейной регрессии
  • Вывод

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

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

К концу этой статьи вы узнаете:

  • Что такое линейная регрессия
  • Для чего используется линейная регрессия
  • Как работает линейная регрессия
  • Как реализовать линейную регрессию в Python, шаг за шагом

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

регрессия

Регрессионный анализ – одна из важнейших областей статистики и машинного обучения. Есть много методов регрессии. Линейная регрессия является одним из них.

Что такое регрессия?

Регрессия ищет отношения между переменными.

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

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

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

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

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

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

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

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

Обычной практикой является обозначение выходов с помощью 𝑦 и входов с помощью 𝑥. Если существует две или более независимых переменных, они могут быть представлены в виде вектора 𝐱 = (𝑥₁,…, 𝑥ᵣ), где 𝑟 – количество входов.

Когда вам нужен регресс?

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

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

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

Линейная регрессия

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

Постановка проблемы

При реализации линейной регрессии некоторой зависимой переменной 𝑦 на множестве независимых переменных 𝐱 = (𝑥₁,…, 𝑥ᵣ), где 𝑟 – число предикторов, вы предполагаете линейную зависимость между 𝑦 и 𝐱: 𝑦 = 𝛽₀ + 𝛽₁𝑥₁ + ⋯ + 𝛽ᵣ𝑥ᵣ + 𝜀. Это уравнение является уравнением регрессии . 𝛽₀, 𝛽₁,…, 𝛽ᵣ – коэффициенты регрессии , а 𝜀 – случайная ошибка .

Линейная регрессия вычисляет оценки коэффициентов регрессии или просто прогнозируемые веса , обозначенные как 𝑏₀, 𝑏₁,…, 𝑏ᵣ. Они определяют оценочную функцию регрессии 𝑓 (𝐱) = 𝑏₀ + 𝑏₁𝑥₁ + ⋯ + 𝑏ᵣ𝑥ᵣ. Эта функция должна достаточно хорошо фиксировать зависимости между входами и выходами.

Оценки или предсказан ответ , 𝑓 (𝐱ᵢ), для каждого наблюдения 𝑖 = 1, …, 𝑛, должен быть как можно ближе к соответствующей действительной реакции 𝑦ᵢ. Различия 𝑦ᵢ – 𝑓 (𝐱ᵢ) для всех наблюдений 𝑖 = 1, …, 𝑛, называются остатки . Регрессия заключается в определении наилучших прогнозируемых весов , то есть весов, соответствующих наименьшим остаткам.

Чтобы получить наилучшие веса, вы обычно минимизируете сумму квадратов невязок (SSR) для всех наблюдений 𝑖 = 1,…, 𝑛: SSR = Σᵢ (𝑦ᵢ – 𝑓 (𝐱ᵢ)) ². Этот подход называется методом наименьших квадратов .

Производительность регрессии

Изменение фактических ответов 𝑦ᵢ, 𝑖 = 1,…, 𝑛 происходит частично из-за зависимости от предикторов 𝐱ᵢ. Тем не менее, есть также дополнительная внутренняя дисперсия на выходе.

Коэффициент детерминации , обозначается как 𝑅², говорит вам , какое количество изменения в 𝑦 можно объяснить зависимость от 𝐱 с использованием конкретной модели регрессии. Больший indicates² указывает на лучшее соответствие и означает, что модель может лучше объяснить изменение выходных данных с различными входными данными.

Значение 𝑅² = 1 соответствует SSR = 0, то есть идеально подходит, поскольку значения прогнозируемых и фактических ответов полностью соответствуют друг другу.

Простая линейная регрессия

Простая или однорядная линейная регрессия – это простейший случай линейной регрессии с одной независимой переменной 𝐱 = 𝑥.

На следующем рисунке показана простая линейная регрессия:

Пример простой линейной регрессии
Пример простой линейной регрессии

При реализации простой линейной регрессии вы обычно начинаете с заданного набора пар ввода-вывода (𝑥-𝑦) (зеленые кружки). Эти пары – ваши наблюдения. Например, крайнее левое наблюдение (зеленый кружок) имеет вход 𝑥 = 5 и фактический выход (ответ) 𝑦 = 5. Следующее имеет 𝑥 = 15 и 𝑦 = 20, и так далее.

Расчетная функция регрессии (черная линия) имеет уравнение 𝑓 (𝑥) = 𝑏₀ + 𝑏₁𝑥. Ваша цель состоит в том, чтобы рассчитать оптимальные значения прогнозируемых весов 𝑏₀ и 𝑏₁, которые минимизируют SSR и определяют оценочную функцию регрессии. Значение 𝑏₀, также называемый перехват , показывает точку , где расчетная линия регрессии пересекает ось 𝑦. Это значение оценочного ответа 𝑓 (𝑥) для for = 0. Значение 𝑏₁ определяет наклон оценочной линии регрессии.

Предсказанные ответы (красные квадраты) – это точки на линии регрессии, которые соответствуют входным значениям. Например, для входа 5 = 5 прогнозируемый ответ равен 𝑓 (5) = 8,33 (представлен крайним левым красным квадратом).

Остатки (вертикальные пунктирные серые линии) можно рассчитать как 𝑦ᵢ – 𝑓 (𝐱ᵢ) = 𝑦ᵢ – 𝑏₀ – 𝑏₁𝑥ᵢ для 𝑖 = 1,…, 𝑛. Это расстояния между зелеными кружками и красными квадратами. Когда вы реализуете линейную регрессию, вы на самом деле пытаетесь минимизировать эти расстояния и сделать красные квадраты как можно ближе к заранее определенным зеленым кружкам.

Множественная линейная регрессия

Множественная или многомерная линейная регрессия – это случай линейной регрессии с двумя или более независимыми переменными.

Если существует только две независимые переменные, оценочная регрессионная функция равна 𝑓 (𝑥₁, 𝑥₂) = 𝑏₀ + 𝑏₁𝑥₁ + 𝑏₂𝑥₂. Он представляет плоскость регрессии в трехмерном пространстве. Цель регрессии состоит в том, чтобы определить значения весов 𝑏₀, 𝑏₂ и 𝑏₂ так, чтобы эта плоскость была как можно ближе к фактическим ответам и дать минимальный SSR.

Случай более двух независимых переменных похож, но более общий. Оценочная функция регрессии: 𝑓 (𝑥₁,…, 𝑥ᵣ) = 𝑏₀ + 𝑏₁𝑥₁ + ⋯ + 𝑏ᵣ𝑥ᵣ, и есть when + 1 весовые коэффициенты, которые должны быть определены, когда число входов равно 𝑟.

Полиномиальная регрессия

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

Другими словами, в дополнение к линейным терминам, таким как 𝑏₁𝑥₁, ваша функция регрессии 𝑓 может включать нелинейные термины, такие как 𝑏₂𝑥₁², 𝑏₃𝑥₁³ или даже 𝑏₄𝑥₁𝑥₂, 𝑏₅𝑥₁²𝑥₂ и т. Д.

Простейший пример полиномиальной регрессии имеет одну независимую переменную, а оценочная функция регрессии – это полином степени 2: 𝑓 (𝑥) = 𝑏₀ + 𝑏₁𝑥 + 𝑏₂𝑥².

Теперь запомните, что вы хотите рассчитать 𝑏₀, 𝑏₁ и 𝑏₂, которые минимизируют SSR. Это ваши неизвестные!

Имея это в виду, сравните предыдущую функцию регрессии с функцией 𝑓 (𝑥₁, 𝑥₂) = 𝑏₀ + 𝑏₁𝑥₁ + 𝑏₂𝑥₂, используемой для линейной регрессии. Они выглядят очень похоже и являются линейными функциями от неизвестных 𝑏₀, 𝑏₁ и 𝑏₂. Вот почему вы можете решить проблему полиномиальной регрессии как линейную задачу с термином regarded², который рассматривается как входная переменная.

В случае двух переменных и многочлена степени 2 функция регрессии имеет следующий вид: 𝑓 (𝑥₁, 𝑥₂) = 𝑏₀ + 𝑏₁𝑥₁ + 𝑏₂𝑥₂ + 𝑏₃𝑥₁² + 𝑏₄𝑥₁𝑥₂ + 𝑏₅𝑥₂². Процедура решения проблемы идентична предыдущему случаю. Вы применяете линейную регрессию для пяти входов: 𝑥₁, 𝑥₂, 𝑥₁², 𝑥₁𝑥₂ и 𝑥₂². В результате регрессии вы получаете значения шести весов, которые минимизируют SSR: 𝑏₀, 𝑏₁, 𝑏₂, 𝑏₃, 𝑏₄ и 𝑏₅.

Конечно, есть более общие проблемы, но этого должно быть достаточно, чтобы проиллюстрировать это.

Подгонка и переоснащение

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

Для этого не существует простого правила. Это зависит от случая. Вы должны, однако, иметь в виду две проблемы , которые могут последовать выбор степени: underfitting и переобучения .

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

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

Следующий рисунок иллюстрирует недостаточно оснащенные, хорошо подогнанные и переоснащенные модели:

Пример недостаточно приспособленных, хорошо подогнанных и переоснащенных моделей
Пример недостаточно приспособленных, хорошо подогнанных и переоснащенных моделей

Верхний левый график показывает линию линейной регрессии с низким значением 𝑅². Также может быть важно, что прямая линия не может принять во внимание тот факт, что фактический отклик увеличивается при 𝑥 от 25 к нулю. Это, вероятно, пример недостаточного оснащения.

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

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

Наконец, на нижнем правом графике вы можете увидеть идеальное соответствие: шесть точек и полиномиальная линия степени 5 (или выше) дают 𝑅² = 1. Каждый фактический ответ равен соответствующему прогнозу.

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

Например, предполагается, что без каких-либо доказательств наблюдается значительное снижение ответов для for> 50 и что 𝑦 достигает нуля для for около 60. Такое поведение является следствием чрезмерных усилий по изучению и подгонке существующих данных.

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

Реализация линейной регрессии в Python

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

Пакеты Python для линейной регрессии

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

Если вы не знакомы с NumPy, вы можете использовать официальное руководство пользователя NumPy и прочитать Look Ma, No For-Loops: программирование массива с помощью NumPy . Кроме того, сравнение производительности между Pure Python и NumPy с TensorFlow может дать вам довольно хорошее представление о приросте производительности, который вы можете получить при применении NumPy.

Пакет scikit-learn – это широко используемая библиотека Python для машинного обучения, построенная на основе NumPy и некоторых других пакетов. Он предоставляет средства для предварительной обработки данных, уменьшения размерности, реализации регрессии, классификации, кластеризации и многого другого. Как и NumPy, scikit-learn также является открытым исходным кодом.

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

Если вы хотите реализовать линейную регрессию и нуждаетесь в функциональности, выходящей за рамки scikit-learn, вам следует подумать об этом statsmodels. Это мощный пакет Python для оценки статистических моделей, выполнения тестов и многого другого. Это также открытый исходный код.

Вы можете найти больше информации statsmodelsна его официальном веб-сайте .

Простая линейная регрессия с scikit-learn

Давайте начнем с самого простого случая, который является простой линейной регрессией.

Существует пять основных шагов при реализации линейной регрессии:

  1. Импортируйте нужные вам пакеты и классы.
  2. Предоставить данные для работы и в конечном итоге сделать соответствующие преобразования.
  3. Создайте модель регрессии и дополните ее существующими данными.
  4. Проверьте результаты подгонки модели, чтобы узнать, является ли модель удовлетворительной.
  5. Примените модель для прогнозов.

Эти шаги являются более или менее общими для большинства регрессионных подходов и реализаций.

Шаг 1: Импорт пакетов и классов

Первый шаг – импортировать пакет numpyи класс LinearRegressionиз sklearn.linear_model:

import numpy as np
from sklearn.linear_model import LinearRegression

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

Основным типом данных NumPy является вызываемый тип массива numpy.ndarray. В оставшейся части этой статьи термин « массив» используется для обозначения экземпляров типа numpy.ndarray.

Этот класс sklearn.linear_model.LinearRegressionбудет использоваться для выполнения линейной и полиномиальной регрессии и соответствующего прогнозирования.

Шаг 2: предоставить данные

Второй шаг – определение данных для работы. Входные данные (регрессоры, 𝑥) и выходные данные (предиктор, 𝑦) должны быть массивами (экземплярами класса numpy.ndarray) или подобными объектами. Это самый простой способ предоставления данных для регрессии:

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([5, 20, 14, 32, 22, 38])

Теперь у вас есть два массива: вход xи выход y. Вы должны позвонить .reshape()на , xпотому что этот массив должен быть двумерным , или быть более точным, чтобы иметь один столбец и столько строк , сколько необходимо . Это именно то , что аргумент (-1, 1)о .reshape()специфицирует.

Вот так xи yвыглядишь сейчас:>>>

>>> print(x)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> print(y)
[ 5 20 14 32 22 38]

Как видите, xимеет два измерения и x.shapeесть (6, 1), а yимеет одно измерение и y.shapeесть (6,).

Шаг 3: Создать модель и подогнать ее

Следующим шагом является создание модели линейной регрессии и ее подгонка с использованием существующих данных.

Давайте создадим экземпляр класса LinearRegression, который будет представлять модель регрессии:

model = LinearRegression()

Этот оператор создает переменную modelкак экземпляр LinearRegression. Вы можете предоставить несколько необязательных параметров для LinearRegression:

  • fit_interceptявляется логическим ( Trueпо умолчанию), который решает, вычислять ли пересечение 𝑏₀ ( True) или считать его равным нулю ( False).
  • normalizeявляется логическим ( Falseпо умолчанию), который решает, нормализовать ли входные переменные ( True) или нет ( False).
  • copy_Xявляется логическим ( Trueпо умолчанию), который решает, копировать ( True) или перезаписать входные переменные ( False).
  • n_jobsявляется целым числом или None(по умолчанию) и представляет количество заданий, используемых в параллельных вычислениях. NoneОбычно означает одну работу и -1использовать все процессоры.

В этом примере используются значения по умолчанию всех параметров.

Пришло время начать использовать модель. Во- первых, вам нужно позвонить .fit()по model:

model.fit(x, y)

С помощью .fit()вы вычисляете оптимальные значения весов 𝑏₀ и 𝑏₁, используя существующие входные и выходные данные ( xи y) в качестве аргументов. Другими словами, .fit() подходит модель . Возвращает self, которая является самой переменной model. Вот почему вы можете заменить два последних утверждения следующим:

model = LinearRegression().fit(x, y)

Это утверждение делает то же самое, что и два предыдущих. Это просто короче.

Шаг 4: Получить результаты

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

Вы можете получить коэффициент детерминации (𝑅²) с .score()названием на model:>>>

>>> r_sq = model.score(x, y)
>>> print('coefficient of determination:', r_sq)
coefficient of determination: 0.715875613747954

При применении .score()аргументы также являются предиктором xи регрессором y, а возвращаемое значение равно 𝑅².

Атрибуты modelявляются .intercept_, который представляет собой коэффициент, и .coef_, который представляет собой:>>>

>>> print('intercept:', model.intercept_)
intercept: 5.633333333333329
>>> print('slope:', model.coef_)
slope: [0.54]

Код выше показывает, как получить 𝑏₀ и 𝑏₁. Вы можете заметить, что .intercept_это скаляр, а .coef_массив.

Значение 𝑏₀ = 5.63 (приблизительно) показывает, что ваша модель предсказывает отклик 5.63, когда 𝑥 равен нулю. Значение 𝑏₁ = 0,54 означает, что предсказанный отклик возрастает на 0,54 при увеличении one на единицу.

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

>>> new_model = LinearRegression().fit(x, y.reshape((-1, 1)))
>>> print('intercept:', new_model.intercept_)
intercept: [5.63333333]
>>> print('slope:', new_model.coef_)
slope: [[0.54]]

Как видите, этот пример очень похож на предыдущий, но в данном случае .intercept_это одномерный массив с одним элементом 𝑏₀ и .coef_двумерный массив с одним элементом 𝑏₁.

Шаг 5: Предсказать ответ

Когда есть удовлетворительная модель, вы можете использовать ее для прогнозов с существующими или новыми данными.

Чтобы получить прогнозируемый ответ, используйте .predict():>>>

>>> y_pred = model.predict(x)
>>> print('predicted response:', y_pred, sep='\n')
predicted response:
[ 8.33333333 13.73333333 19.13333333 24.53333333 29.93333333 35.33333333]

При применении .predict()вы передаете регрессор в качестве аргумента и получаете соответствующий предсказанный ответ.

Это почти идентичный способ предсказать ответ:>>>

>>> y_pred = model.intercept_ + model.coef_ * x
>>> print('predicted response:', y_pred, sep='\n')
predicted response:
[[ 8.33333333]
 [13.73333333]
 [19.13333333]
 [24.53333333]
 [29.93333333]
 [35.33333333]]

В этом случае нужно умножить каждый элемент xс model.coef_и добавить model.intercept_к продукту.

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

Если вы уменьшите число измерений xдо одного, эти два подхода дадут одинаковый результат. Вы можете сделать это путем замены xс x.reshape(-1)x.flatten()или x.ravel()при умножении его model.coef_.

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

>>> x_new = np.arange(5).reshape((-1, 1))
>>> print(x_new)
[[0]
 [1]
 [2]
 [3]
 [4]]
>>> y_new = model.predict(x_new)
>>> print(y_new)
[5.63333333 6.17333333 6.71333333 7.25333333 7.79333333]

Здесь .predict()применяется новый регрессор x_newи дает ответ y_new. Этот пример использует удобно arange()от numpyгенерировать массив с элементами из 0 (включительно) до 5 (исключительного), то есть 0123, и 4.

Вы можете найти более подробную информацию о LinearRegressionна официальной странице документации .

Множественная линейная регрессия с scikit-learn

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

Шаги 1 и 2: импорт пакетов и классов и предоставление данных

Сначала вы импортируете numpyи sklearn.linear_model.LinearRegressionпредоставляете известные входные и выходные данные:

import numpy as np
from sklearn.linear_model import LinearRegression

x = [[0, 1], [5, 1], [15, 2], [25, 5], [35, 11], [45, 15], [55, 34], [60, 35]]
y = [4, 5, 20, 14, 32, 22, 38, 43]
x, y = np.array(x), np.array(y)

Это простой способ определить вход xи выход y. Вы можете распечатать xи yпосмотреть, как они выглядят сейчас:>>>

>>> print(x)
[[ 0  1]
 [ 5  1]
 [15  2]
 [25  5]
 [35 11]
 [45 15]
 [55 34]
 [60 35]]
>>> print(y)
[ 4  5 20 14 32 22 38 43]

При множественной линейной регрессии x– это двумерный массив, по крайней мере, с двумя столбцами, в то время yкак обычно это одномерный массив. Это простой пример множественной линейной регрессии и xсодержит ровно два столбца.

Шаг 3: Создать модель и подогнать ее

Следующим шагом является создание регрессионной модели как экземпляра LinearRegressionи подгонка ее под .fit():

model = LinearRegression().fit(x, y)

Результатом этого оператора является переменная, modelссылающаяся на объект типа LinearRegression. Он представляет регрессионную модель, дополненную существующими данными.

Шаг 4: Получить результаты

Вы можете получить свойства модели так же, как и в случае простой линейной регрессии:>>>

>>> r_sq = model.score(x, y)
>>> print('coefficient of determination:', r_sq)
coefficient of determination: 0.8615939258756776
>>> print('intercept:', model.intercept_)
intercept: 5.52257927519819
>>> print('slope:', model.coef_)
slope: [0.44706965 0.25502548]

Вы получаете значение using², используя .score()и значения оценок коэффициентов регрессии с помощью .intercept_и .coef_. Опять же, .intercept_имеет смещение 𝑏₀, а теперь .coef_это массив, содержащий 𝑏₁ и 𝑏₂ соответственно.

В этом примере перехват составляет приблизительно 5,52, и это значение прогнозируемого отклика, когда 𝑥₁ = 𝑥₂ = 0. Увеличение 𝑥₁ на 1 приводит к увеличению прогнозируемого отклика на 0,45. Аналогично, когда 𝑥₂ возрастает на 1, отклик возрастает на 0,26.

Шаг 5: Предсказать ответ

Прогнозы также работают так же, как и в случае простой линейной регрессии:>>>

>>> y_pred = model.predict(x)
>>> print('predicted response:', y_pred, sep='\n')
predicted response:
[ 5.77760476  8.012953   12.73867497 17.9744479  23.97529728 29.4660957
 38.78227633 41.27265006]

Предсказанный ответ получен с .predict(), который очень похож на следующее:>>>

>>> y_pred = model.intercept_ + np.sum(model.coef_ * x, axis=1)
>>> print('predicted response:', y_pred, sep='\n')
predicted response:
[ 5.77760476  8.012953   12.73867497 17.9744479  23.97529728 29.4660957
 38.78227633 41.27265006]

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

Вы можете применить эту модель и к новым данным:>>>

>>> x_new = np.arange(10).reshape((-1, 2))
>>> print(x_new)
[[0 1]
 [2 3]
 [4 5]
 [6 7]
 [8 9]]
>>> y_new = model.predict(x_new)
>>> print(y_new)
[ 5.77760476  7.18179502  8.58598528  9.99017554 11.3943658 ]

Это прогноз с использованием модели линейной регрессии.

Полиномиальная регрессия с scikit-Learn

Реализация полиномиальной регрессии с помощью scikit-learn очень похожа на линейную регрессию. Есть только один дополнительный шаг: вам нужно преобразовать массив входных данных, чтобы включить нелинейные термины, такие как 𝑥².

Шаг 1: Импорт пакетов и классов

В дополнение к numpyи sklearn.linear_model.LinearRegression, вы также должны импортировать класс PolynomialFeaturesиз sklearn.preprocessing:

import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures

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

Шаг 2а: предоставить данные

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

x = np.array([5, 15, 25, 35, 45, 55]).reshape((-1, 1))
y = np.array([15, 11, 2, 8, 25, 32])

Теперь у вас есть вход и выход в подходящем формате. Имейте в виду, что вам нужно, чтобы вход был двумерным массивом . Вот почему .reshape()используется.

Шаг 2b: преобразование входных данных

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

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

Можно преобразовать входной массив несколькими способами (например, используя insert()from numpy), но класс PolynomialFeaturesочень удобен для этой цели. Давайте создадим экземпляр этого класса:

transformer = PolynomialFeatures(degree=2, include_bias=False)

Переменная transformerотносится к экземпляру, PolynomialFeaturesкоторый вы можете использовать для преобразования ввода x.

Вы можете предоставить несколько необязательных параметров для PolynomialFeatures:

  • degreeявляется целым числом ( 2по умолчанию), которое представляет степень функции полиномиальной регрессии.
  • interaction_onlyявляется логическим ( Falseпо умолчанию), который решает, включать ли только функции взаимодействия ( True) или все функции ( False).
  • include_biasявляется логическим ( Trueпо умолчанию), который решает, включать ли столбец смещения (перехвата) в ones ( True) или нет ( False).

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

Перед применением transformerвам необходимо установить .fit():

transformer.fit(x)

После transformerустановки он готов создать новый, измененный ввод. Вы обращаетесь, .transform()чтобы сделать это:

x_ = transformer.transform(x)

Это преобразование входного массива с .transform(). Он принимает входной массив в качестве аргумента и возвращает измененный массив.

Вы также можете использовать .fit_transform()для замены трех предыдущих операторов только один:

x_ = PolynomialFeatures(degree=2, include_bias=False).fit_transform(x)

Это соответствует и преобразует входной массив в одну инструкцию с .fit_transform(). Он также принимает входной массив и эффективно делает то же самое, что .fit()и вызывается в этом .transform()порядке. Он также возвращает измененный массив. Вот как выглядит новый входной массив:>>>

>>> print(x_)
[[   5.   25.]
 [  15.  225.]
 [  25.  625.]
 [  35. 1225.]
 [  45. 2025.]
 [  55. 3025.]]

Модифицированный входной массив содержит два столбца: один с исходными входами, а другой с их квадратами.

Вы можете найти более подробную информацию о PolynomialFeaturesна официальной странице документации .

Шаг 3: Создать модель и подогнать ее

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

model = LinearRegression().fit(x_, y)

Модель регрессии теперь создана и подогнана. Он готов к применению.

Следует помнить, что первый аргумент .fit()– это модифицированный входной массив, x_ а не оригинал x.

Шаг 4: Получить результаты

Вы можете получить свойства модели так же, как и в случае линейной регрессии:>>>

>>> r_sq = model.score(x_, y)
>>> print('coefficient of determination:', r_sq)
coefficient of determination: 0.8908516262498564
>>> print('intercept:', model.intercept_)
intercept: 21.372321428571425
>>> print('coefficients:', model.coef_)
coefficients: [-1.32357143  0.02839286]

Снова .score()возвращается 𝑅². Его первым аргументом также является измененный ввод x_, а не x. Значения весов связаны с .intercept_и .coef_.intercept_представляет 𝑏₀, а .coef_ссылается на массив, который содержит 𝑏₁ и 𝑏₂ соответственно.

Вы можете получить очень похожий результат с различными аргументами преобразования и регрессии:

x_ = PolynomialFeatures(degree=2, include_bias=True).fit_transform(x)

Если вы вызовете PolynomialFeaturesс параметром по умолчанию include_bias=True(или просто опустите его), вы получите новый входной массив x_с дополнительным крайним левым столбцом, содержащим только один. Этот столбец соответствует перехвату. Вот как выглядит модифицированный входной массив в этом случае:>>>

>>> print(x_)
[[1.000e+00 5.000e+00 2.500e+01]
 [1.000e+00 1.500e+01 2.250e+02]
 [1.000e+00 2.500e+01 6.250e+02]
 [1.000e+00 3.500e+01 1.225e+03]
 [1.000e+00 4.500e+01 2.025e+03]
 [1.000e+00 5.500e+01 3.025e+03]]

Первый столбец x_содержит единицы, второй имеет значения x, а третий содержит квадраты x.

Перехват уже включен в самый левый столбец единиц, и вам не нужно включать его снова при создании экземпляра LinearRegression. Таким образом, вы можете предоставить fit_intercept=False. Вот как выглядит следующее утверждение:

model = LinearRegression(fit_intercept=False).fit(x_, y)

Переменная modelснова соответствует новому входному массиву x_. Поэтому x_должен быть передан в качестве первого аргумента вместо x.

Этот подход дает следующие результаты, которые похожи на предыдущий случай:>>>

>>> r_sq = model.score(x_, y)
>>> print('coefficient of determination:', r_sq)
coefficient of determination: 0.8908516262498565
>>> print('intercept:', model.intercept_)
intercept: 0.0
>>> print('coefficients:', model.coef_)
coefficients: [21.37232143 -1.32357143  0.02839286]

Вы видите, что теперь .intercept_это ноль, но .coef_фактически содержит 𝑏₀ в качестве первого элемента. Все остальное тоже самое.

Шаг 5: Предсказать ответ

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

>>> y_pred = model.predict(x_)
>>> print('predicted response:', y_pred, sep='\n')
predicted response:
[15.46428571  7.90714286  6.02857143  9.82857143 19.30714286 34.46428571]

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

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

# Step 1: Import packages
import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures

# Step 2a: Provide data
x = [[0, 1], [5, 1], [15, 2], [25, 5], [35, 11], [45, 15], [55, 34], [60, 35]]
y = [4, 5, 20, 14, 32, 22, 38, 43]
x, y = np.array(x), np.array(y)

# Step 2b: Transform input data
x_ = PolynomialFeatures(degree=2, include_bias=False).fit_transform(x)

# Step 3: Create a model and fit it
model = LinearRegression().fit(x_, y)

# Step 4: Get results
r_sq = model.score(x_, y)
intercept, coefficients = model.intercept_, model.coef_

# Step 5: Predict
y_pred = model.predict(x_)

Этот пример регрессии дает следующие результаты и прогнозы:>>>

>>> print('coefficient of determination:', r_sq)
coefficient of determination: 0.9453701449127822
>>> print('intercept:', intercept)
intercept: 0.8430556452395734
>>> print('coefficients:', coefficients, sep='\n')
coefficients:
[ 2.44828275  0.16160353 -0.15259677  0.47928683 -0.4641851 ]
>>> print('predicted response:', y_pred, sep='\n')
predicted response:
[ 0.54047408 11.36340283 16.07809622 15.79139    29.73858619 23.50834636
 39.05631386 41.92339046]

В этом случае существует шесть коэффициентов регрессии (включая пересечение), как показано в оценочной функции регрессии 𝑓 (𝑥₁, 𝑥₂) = 𝑏₀ + 𝑏₁𝑥₁ + 𝑏₂𝑥₂ + 𝑏₃𝑥₁² + 𝑏₄𝑥₁𝑥₂ + 𝑏₅𝑥₂².

Вы также можете заметить, что полиномиальная регрессия дала более высокий коэффициент детерминации, чем множественная линейная регрессия для одной и той же задачи. Сначала вы можете подумать, что получение такого большого 𝑅² – отличный результат. Может быть.

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

Продвинутая линейная регрессия с statsmodels

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

Процедура похожа на ту, что есть в scikit-learn.

Шаг 1: Импорт пакетов

Сначала вам нужно сделать несколько импортов. Кроме того numpy, вам необходимо импортировать statsmodels.api:

import numpy as np
import statsmodels.api as sm

Теперь у вас есть пакеты, которые вам нужны.

Шаг 2: предоставить данные и преобразовать входные данные

Вы можете предоставить входы и выходы так же, как и при использовании scikit-learn:

x = [[0, 1], [5, 1], [15, 2], [25, 5], [35, 11], [45, 15], [55, 34], [60, 35]]
y = [4, 5, 20, 14, 32, 22, 38, 43]
x, y = np.array(x), np.array(y)

Массивы ввода и вывода созданы, но работа еще не выполнена.

Вам нужно добавить столбец единиц на входы, если вы хотите statsmodelsвычислить перехват 𝑏₀. Это не учитывает 𝑏₀ по умолчанию. Это всего лишь один вызов функции:

x = sm.add_constant(x)

Вот как вы добавляете столбец единиц в xс add_constant(). Он принимает входной массив xв качестве аргумента и возвращает новый массив со столбцом единиц, вставленным в начале. Вот так xи yвыглядишь сейчас:>>>

>>> print(x)
[[ 1.  0.  1.]
 [ 1.  5.  1.]
 [ 1. 15.  2.]
 [ 1. 25.  5.]
 [ 1. 35. 11.]
 [ 1. 45. 15.]
 [ 1. 55. 34.]
 [ 1. 60. 35.]]
>>> print(y)
[ 4  5 20 14 32 22 38 43]

Вы можете видеть, что измененный xимеет три столбца: первый столбец из них (соответствует 𝑏₀ и заменяет перехват), а также два столбца исходных объектов.

Шаг 3: Создать модель и подогнать ее

Модель регрессии, основанная на обычных наименьших квадратах, является экземпляром класса statsmodels.regression.linear_model.OLS. Вот как вы можете получить один:

model = sm.OLS(y, x)

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

Чтобы найти больше информации об этом классе, пожалуйста, посетите официальную страницу документации .

После того, как ваша модель создана, вы можете применить .fit()к ней:

results = model.fit()

Вызывая .fit(), вы получаете переменную results, которая является экземпляром класса statsmodels.regression.linear_model.RegressionResultsWrapper. Этот объект содержит много информации о регрессионной модели.

Шаг 4: Получить результаты

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

Вы можете позвонить, .summary()чтобы получить таблицу с результатами линейной регрессии:>>>

>>> print(results.summary())
OLS Regression Results                            
==============================================================================
Dep. Variable:                      y   R-squared:                       0.862
Model:                            OLS   Adj. R-squared:                  0.806
Method:                 Least Squares   F-statistic:                     15.56
Date:                Sun, 17 Feb 2019   Prob (F-statistic):            0.00713
Time:                        19:15:07   Log-Likelihood:                -24.316
No. Observations:                   8   AIC:                             54.63
Df Residuals:                       5   BIC:                             54.87
Df Model:                           2                                         
Covariance Type:            nonrobust                                         
==============================================================================
coef    std err          t      P>|t|      [0.025      0.975]
------------------------------------------------------------------------------
const          5.5226      4.431      1.246      0.268      -5.867      16.912
x1             0.4471      0.285      1.567      0.178      -0.286       1.180
x2             0.2550      0.453      0.563      0.598      -0.910       1.420
==============================================================================
Omnibus:                        0.561   Durbin-Watson:                   3.268
Prob(Omnibus):                  0.755   Jarque-Bera (JB):                0.534
Skew:                           0.380   Prob(JB):                        0.766
Kurtosis:                       1.987   Cond. No.                         80.1
==============================================================================

Warnings:
[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.

Эта таблица очень полная. Вы можете найти много статистических значений, связанных с линейной регрессией, включая 𝑅², 𝑏₀, 𝑏₁ и 𝑏₂.

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

Вы можете извлечь любое из значений из таблицы выше. Вот пример:>>>

>>> print('coefficient of determination:', results.rsquared)
coefficient of determination: 0.8615939258756777
>>> print('adjusted coefficient of determination:', results.rsquared_adj)
adjusted coefficient of determination: 0.8062314962259488
>>> print('regression coefficients:', results.params)
regression coefficients: [5.52257928 0.44706965 0.25502548]

Вот как вы получаете некоторые результаты линейной регрессии:

  1. .rsquared держит 𝑅².
  2. .rsquared_adj представляет настроенный 𝑅² (𝑅², скорректированный в соответствии с количеством входных функций).
  3. .params ссылается на массив с 𝑏₀, 𝑏₁ и 𝑏₂ соответственно.

Вы также можете заметить, что эти результаты идентичны результатам, полученным с помощью scikit-learn для той же задачи.

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

Шаг 5: Предсказать ответ

Вы можете получить прогнозируемый ответ на входные значения, используемые для создания модели, используя .fittedvaluesили .predict()используя входной массив в качестве аргумента:>>>

>>> print('predicted response:', results.fittedvalues, sep='\n')
predicted response:
[ 5.77760476  8.012953   12.73867497 17.9744479  23.97529728 29.4660957
 38.78227633 41.27265006]
>>> print('predicted response:', results.predict(x), sep='\n')
predicted response:
[ 5.77760476  8.012953   12.73867497 17.9744479  23.97529728 29.4660957
 38.78227633 41.27265006]

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

>>> x_new = sm.add_constant(np.arange(10).reshape((-1, 2)))
>>> print(x_new)
[[1. 0. 1.]
 [1. 2. 3.]
 [1. 4. 5.]
 [1. 6. 7.]
 [1. 8. 9.]]
>>> y_new = results.predict(x_new)
>>> print(y_new)
[ 5.77760476  7.18179502  8.58598528  9.99017554 11.3943658 ]

Вы можете заметить, что предсказанные результаты такие же, как и полученные с помощью scikit-learn для той же задачи.

За пределами линейной регрессии

Линейная регрессия иногда не подходит, особенно для нелинейных моделей высокой сложности.

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

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

Пакет scikit-learn предоставляет средства для использования других методов регрессии очень похожим на то, что вы видели. Он содержит классы для поддержки векторных машин, деревья решений, случайного леса, и многое другое, с помощью методов .fit().predict().score()и так далее.

Вывод

Теперь вы знаете, что такое линейная регрессия и как ее реализовать с помощью Python и трех пакетов с открытым исходным кодом: NumPy, scikit-learn и statsmodels.

Вы используете NumPy для работы с массивами.

Линейная регрессия реализуется с помощью следующего:

  • scikit – учитесь, если вам не нужны подробные результаты и вы хотите использовать подход, совместимый с другими методами регрессии
  • statsmodels, если вам нужны расширенные статистические параметры модели

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

При выполнении линейной регрессии в Python вы можете выполнить следующие шаги:

  1. Импортируйте нужные вам пакеты и классы
  2. Предоставить данные для работы и в конечном итоге сделать соответствующие преобразования
  3. Создать регрессионную модель и дополнить ее существующими данными.
  4. Проверьте результаты подгонки модели, чтобы узнать, является ли модель удовлетворительной
  5. Применить модель для прогнозов

Совершенствуй знания каждый день у нас в Телеграм-каналах

Вопросы, реклама — VK | Telegram