Разное

Linear regression sklearn: Page not found · GitHub Pages

Содержание

Линейная регрессия на Python: объясняем на пальцах

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

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

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

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

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

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

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

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

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

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

Общей практикой является обозначение данных на выходе – ?, входных данных – ?. В случае с двумя или более независимыми переменными, их можно представить в виде вектора ? = (?₁, …, ?ᵣ), где ? – количество входных переменных.

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

Где она вообще нужна?

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

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

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

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

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

Для каждого результата наблюдения ? = 1, …, ?, оценочный или предсказанный ответ ?(?ᵢ) должен быть как можно ближе к соответствующему фактическому ответу ?ᵢ. Разницы от ?ᵢ − ?(?ᵢ) для всех результатов наблюдений ? = 1, …, ? называются остатками. Регрессия определяет лучшие прогнозируемые весы измерения, которые соответствуют наименьшим остаткам.

Для получения лучших весов, вам нужно минимизировать сумму остаточных квадратов (SSR) для всех результатов наблюдений  ? = 1, …, ?: SSR = Σᵢ(?ᵢ − ?(?ᵢ))². Этот подход называется методом наименьших квадратов.

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

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

А вот и она:

Реализация простой линейной регрессии начинается с заданным набором пар (зелёные круги) входов-выходов (?-?). Эти пары – результаты наблюдений. Наблюдение, крайнее слева (зелёный круг) имеет на входе ? = 5 и соответствующий выход (ответ) ? = 5. Следующее наблюдение имеет  ? = 15 и ? = 20, и так далее.

Оценочная функция регрессии (чёрная линия) выражается уравнением ?(?) = ?₀ + ?₁?. Нужно рассчитать оптимальные значения спрогнозированных весов ?₀ и ?₁ для минимизации SSR и определить оценочную функцию регрессии. Величина ?₀, также называемая отрезком, показывает точку, где расчётная линия регрессии пересекает ось ?. Это значение расчётного ответа ?(?) для ? = 0. Величина ?₁ определяет наклон расчетной линии регрессии.

Предсказанные ответы (красные квадраты) – точки линии регрессии, соответствующие входным значениям. Для входа ? = 5 предсказанный ответ равен ?(5) = 8.33 (представленный крайним левыми квадратом).

Остатки (вертикальные пунктирные серые линии) могут быть вычислены как ?ᵢ − ?(?ᵢ) = ?ᵢ − ?₀ − ?₁?ᵢ для ? = 1, …, ?. Они представляют собой расстояния между зелёными и красными пунктами. При реализации линейной регрессии вы минимизируете эти расстояния и делаете красные квадраты как можно ближе к предопределённым зелёным кругам.

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

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

NumPy – фундаментальный научный пакет для быстрых операций над одномерными и многомерными массивами. Он облегчает математическую рутину и, конечно, находится в open-source.

Незнакомы с NumPy? Начните с официального гайда.

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

Начните знакомство с линейными моделями и работой пакета на сайте scikit-learn.

Простая линейная регрессия со 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).

Вот как x и y выглядят теперь:

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

Шаг 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 используются все доступные процессоры.

Наш пример использует состояния параметров по умолчанию.

Пришло время задействовать model. Сначала вызовите .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 при ?, увеличенным на единицу.

Заметьте, что вы можете предоставить 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 (исключительно) – 0, 1, 2, 3, и 4.

О LinearRegression вы узнаете больше из официальной документации.

Теперь у вас есть своя модель линейной регрессии!

Источник

Нравится Data Science? Другие материалы по теме:

Линейные модели: простая регрессия / Хабр

В прошлый раз мы подробно рассмотрели многообразие линейных моделей. Теперь перейдем от теории к практике и построим самую простую, но все же полезную модель, которую вы легко сможете адаптировать к своим задачам. Модель будет проиллюстрирована кодом на R и Python, причем сразу в трех ароматах: scikit-learn, statsmodels и Patsy.

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

Пусть нам даны исходные данные в виде таблицы со столбцами x1, x2, x3 и y. И мы будем строить линейную модель зависимости y от факторов x, то есть модель будет иметь следующий вид:
y = b0 + b1 x1 + b2 x2 + b3 x3 + ℇ
где x, y — исходные данные, b — параметры модели, — случайная величина.
Поскольку х и y у нас уже есть, то наша задача заключается в расчете параметров b.
Обратите внимание, что мы ввели параметр b0, который также называется intercept, так как наша модельная линия совсем не обязательно будет проходить через начало координат. Если исходные данные отцентрированы, то этот параметр не требуется.
Чтобы построить модель нам также нужно ввести параметрическое предположение относительно — без этого мы не сможем выбрать метод решения. Какой попало метод мы не имеем права применить, потому что рискуем получить сколько угодно ошибочный результат, в то время как нам требуется «достаточно хорошая» оценка параметров модели. Так что для простоты и удобства предположим, что ошибки распределены нормально, поэтому мы можем использовать метод обычных наименьших квадратов (ОНК).
Код на R

# загружаем исходные данные
df <- read.csv("http://roman-kh.github.io/files/linear-models/simple1.csv")
# запускаем расчет модели
# модель glm по умолчанию включает intercept, явно его указывать в данном случае не требуется
g <- glm("y ~ x1 + x2 + x3", data=df)
# выводим коэффициенты модели
coef(g)

Код на Python: общая часть

import numpy as np
import pandas as pd
import statsmodels.api as sm
import patsy as pt
import sklearn.linear_model as lm

# загружаем файл с данными
df = pd.DataFrame.from_csv("http://roman-kh.github.io/files/linear-models/simple1.csv")
# x - таблица с исходными данными факторов (x1, x2, x3)
x = df.iloc[:,:-1]
# y - таблица с исходными данными зависимой переменной
y = df.iloc[:,-1]

Код на Python: scikit-learn

# создаем пустую модель
skm = lm.LinearRegression()
# запускаем расчет параметров для указанных данных
skm.fit(x, y)
# и выведем параметры рассчитанной модели
print skm.intercept_, skm.coef_

Код на Python: statsmodels

# добавим фиктивную переменную для расчета intercept'а
x_ = sm.add_constant(x)
# создаем модель для метода обычных наименьших квадратов (Ordinary Least Squares)
smm = sm.OLS(y, x_)
# запускаем расчет модели
res = smm.fit()
# теперь выведем параметры рассчитанной модели
print res.params

Код на Python: statsmodels с формуламиПереходя с R на Python, многие начинают со statsmodels, потому что в ней есть привычные R’овские формулы:

# создаем модель на основе формулы
smm = sm.OLS.from_formula("y ~ x1 + x2 + x3", data=df)
# запускаем расчет модели
res = smm.fit()
# теперь выведем параметры рассчитанной модели
print res.params

Код на Python: Patsy + numpyБлагодаря библиотеке Patsy вы легко можете использовать R-подобные формулы в любой своей программе:

# создаем матрицу факторов и результатов из формулы и исходного датафрейма
pt_y, pt_x = pt.dmatrices("y ~ x1 + x2 + x3", df)
# вызываем стандартную numpy'вскую процедуру оптимизации по МНК
# кстати, именно ее и вызывает LinearRegression из scikit-learn для неразреженной матрицы с исходными данными
# а для разреженной вызывается scipy.sparse.linalg.lsqr
res = np.linalg.lstsq(pt_x, pt_y)
# достаем коэффициенты модели
b = res[0].ravel()
print b

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

Изучаем данные

Итак, мы уже построили модель… Однако скорее всего мы допустили ошибку, возможно даже и не одну. Поскольку мы не изучили данные, прежде чем браться за модель, то получили модель непонятно чего. Поэтому давайте все же заглянем в данные и посмотрим что там есть.
Как вы помните, в исходной таблице было 4 столбца: x1, x2, x3 и y. И мы построили регрессионную зависимость y от всех x. Поскольку мы не можем одним взглядом сразу охватить весь 4-мерный гиперкуб, то посмотрим на отдельные графики x-y.

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

Теперь пришло время отобразить график, соответствующий построенной модели. И тут стоит обратить внимание, что наша линейная модель — это вовсе не линия, а гиперплоскость, поэтому на двумерном графике мы сможем отобразить только отдельный срез этой модельной гиперплоскости. Проще говоря, чтобы показать график модели в координатах x1y надо зафиксировать значения x2 и x3, а, меняя их, получим бесконечное множество графиков — и все они будут графиками модели (а точнее проекцией на плоскость x1y).
Поскольку x3 — бинарный признак — можно показать отдельную линию для каждого значения признака, а x1 и x2 зафиксировать на уровне среднего арифметического, то есть нарисуем графики y=f(x1 | x2=E(x2)) и y=f(x2 | x1=E(x1)), где E — среднее арифметическое по всем значениям x1 и x2 соответственно.

И сразу бросается в глаза, что график y~x2 выглядит как-то неправильно. Помня, что построенная модель должна предсказывать математическое ожидание y, тут мы видим, что модельная линия как раз математическому ожиданию совсем не сооветствует: например в начале графика голубые точки реальных значений находятся ниже голубой линии, а в конце — выше, причем у красной линии все наоборот, хотя обе линии должны проходить примерно посредине облака точек.
Приглядевшись внимательнее, можно догадаться, что голубая и красная линии должны быть даже непараллельны. Как же это сделать в линейной модели? Очевидно, что построив линейную модель у=f(x1,x2,x3) мы можем получить бесконечное количество линий вида y=f(x2 | x1,x3), то есть зафиксировав две из трех переменных. Так, в частности, получены красная линия у=f(x2 | x1=E(x), x3=0) и голубая у=f(x2 | x1=E(x), x3=1) на правом графике. Однако, все подобные линии будут параллельны.

Непараллельная линейная модель

Чтобы внести в модель непараллельность, немного усложним ее, добавив всего одно слагаемое:
y = b0 + b1 x1 + b2 x2 + b3 x3 + b4 x2 x3 + ℇ
К чему это приведет? Раньше любая линия на графике y~x2 имела один и тот же наклон, задаваемый коэффициентом b2. Теперь же в зависимости от значения x3 линия будет иметь наклон b2 (для x3=0) или b2+b4 (для x3=1).
Код на R

# загружаем исходные данные
df <- read.csv("http://roman-kh.github.io/files/linear-models/simple1.csv")
# запускаем расчет модели
# модель glm по умолчанию включает intercept, явно его указывать в данном случае не требуется
g <- glm("y ~ x1 + x2 + x3 + x2*x3", data=df)
# выводим коэффициенты модели
coef(g)

Код на Python: общая часть

import numpy as np
import pandas as pd
import statsmodels.api as sm
import patsy as pt
import sklearn.linear_model as lm

# загружаем файл с данными
df = pd.DataFrame.from_csv("http://roman-kh.github.io/files/linear-models/simple1.csv")
# x - таблица с исходными данными факторов (x1, x2, x3)
x = df.iloc[:,:-1]
# y - таблица с исходными данными зависимой переменной
y = df.iloc[:,-1]

Код на Python: scikit-learn

# создаем новый фактор
x["x4"] = x["x2"] * x["x3"] 
# создаем пустую модель
skm = lm.LinearRegression()
# запускаем расчет параметров для указанных данных
skm.fit(x, y)
# и выведем параметры рассчитанной модели
print skm.intercept_, skm.coef_

Код на Python: statsmodels

# создаем новый фактор
x["x4"] = x["x2"] * x["x3"] 
# добавим фиктивную переменную для расчета intercept'а
x_ = sm.add_constant(x)
# создаем модель для метода обычных наименьших квадратов (Ordinary Least Squares)
smm = sm.OLS(y, x_)
# запускаем расчет модели
res = smm.fit()
# теперь выведем параметры рассчитанной модели
print res.params

Код на Python: statsmodels с формуламиПереходя с R на Python, многие начинают со statsmodels, потому что в ней есть привычные R’овские формулы:

# создаем модель на основе формулы
smm = sm.OLS.from_formula("y ~ x1 + x2 + x3 + x2*x3", data=df)
# запускаем расчет модели
res = smm.fit()
# теперь выведем параметры рассчитанной модели
print res.params

Код на Python: Patsy + numpyБлагодаря библиотеке Patsy вы легко можете использовать R-подобные формулы в любой своей программе:

# создаем матрицу факторов и результатов из формулы и исходного датафрейма
pt_y, pt_x = pt.dmatrices("y ~ x1 + x2 + x3 + x2*x3", df)
# вызываем стандартную numpy'вскую процедуру оптимизации по МНК
# кстати, именно ее и вызывает LinearRegression из scikit-learn для неразреженной матрицы с исходными данными
# а для разреженной вызывается scipy.sparse.linalg.lsqr
res = np.linalg.lstsq(pt_x, pt_y)
# достаем коэффициенты модели
b = res[0].ravel()
print b

А теперь взглянем на обновленный график.

Гораздо лучше!

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

По просьбам желающих я также создал небольшой ipython notebook.

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

Линейная регрессия в ML для чайников c примерами на Python

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

Постановка задачи и исходный датасет

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

import pandas as pd
data = pd.read_csv('../AB_NYC_2019.csv')
data = data[data['neighbourhood_group'] == 'Brooklyn']

На этом наборе данных будем прогнозировать цены, по которым можно арендовать отдельные аппартаменты.

Линейная регрессия с одной независимой переменной

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

Линейная регрессия (красная линия) наиболее полно соответствует точкам

Модель линейной регрессии может быть задана следующим образом:

   

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

   

   

Найдем коэффициенты в Python, написав следующие функции:

def calculate_slope(x, y):
    mx = x - x.mean()
    my = y - y.mean()
    return sum(mx * my) / sum(mx**2)

def get_params(x, y):
    a = calculate_slope(x, y)
    b = y.mean() - a * x.mean()
    return a, b

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

В нашем случае выберем в качестве независимой переменной – количество отзывов number_of_reviews, a зависимой переменной , которую требуется предсказать, будет цена price. Кроме того, чтобы избежать излишней волатильности цены, мы ее прологарифмируем, как это объяснялось в прошлый раз. Посмотрим на полученные коэффициенты:

>>> import numpy as np
import numpy as np
d = data[data.price > 0]
x = d.number_of_reviews
y = np.log(d.price)
a, b = get_params(x, y)

В итоге получили:

>>> a
-0.04213862786693919
>>> b
125.40308200933784

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

   

Построим график в Python-библиотеке matplotlib, на котором будет видна полученная линейная регрессия и истинные значения цены. О том, как строить графики, мы рассказывали тут. Для этого воспользуемся функциями scatter и plot:

import matplotlib.pyplot as plt

plt.xlabel('Количество отзывов')
plt.ylabel('Цена в логарифмическом масштабе')
plt.scatter(x, y)
plt.plot(x, lin_reg, color='red')

В результате получили график:

Линейная регрессия (красная линия)

Как можно заметить, линейная регрессия с одной независимой переменной показывает неудачные результаты, так как является практически параллельной оси абсцисс. Поэтому предсказание будет одним и тем же, примерно равным 4.6. При переводе обратно в нормальный масштаб равняется $100.

Линейная регрессия в библиотеках statsmodel и seaborn

Чтобы получить линейную регрессию, Data Scientist, который работает с Python, может воспользоваться готовыми библиотеками, а не писать собственное решение. Например, отлично подойдет библиотека Statsmodel, о которой мы уже говорили здесь. Она позволит получить линейную регрессию очень быстро:

import statsmodels.formula.api as smf

model = smf.ols('price ~ number_of_reviews', data=data)
res = model.fit()
res.summary()

Метод summary выдает резюме после вычислений линейной регрессии по методу наименьших квадратов. Но нас интересуют коэффициенты и , которые в данном случае равны:

Коэффициенты линейной регрессии

Как видим, intercept – это , number_of reviews, – это , что соответствуют прошлым вычислениям.

Помимо Statsmodel, можно воспользоваться библиотекой Seaborn, которая также часто применяется в задачах Machine Learning и других методах Data Science. Она имеет функцию regplot, которая сразу построит соответствующую прямую:

import seaborn as sns
sns.regplot(x, y)

Линейная регрессия с несколькими переменными в Scikit-learn

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

   

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

Рассмотрим пример в Python. Выберем в качестве независимых переменных признаки: number_of_reviews, reviews_per_month, calculated_host_listings_count. Атрибут reviews_per_month имеет Nan-значения, поэтому в дальнейшем заполним их нулями. К тому же, мы отфильтровали те данные, которые имеют нулевую цену:

d = data[data.price > 0]
d['reviews_per_month'].fillna(0, inplace=True)

x = d.loc[:, ('reviews_per_month',
              'calculated_host_listings_count',
              'number_of_reviews')]
y = d.loc[:, 'price']

Здесь используется метод loc, который, согласно документации, быстрее и производительнее явного вызова столбцов [1]. Нам также требуется разбить полученные данные на тренировочную и тестовую выборки, чтобы на одних данных обучить модель, а на других – проверить ее корректность. В Scikit-learn имеется функция train_test_split, возвращающая две пары массивов – тренировочного и тестового:

from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)

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

Теперь к самому главному – обучению модели линейной регрессии. В Scikit-learn есть класс LinearRegression, который выполнит за нас работу в Python:

from sklearn.linear_model import LinearRegression
model = LinearRegression().fit(x_train, y_train)

В метод fit мы посылаем те данные, на которых ML-модель обучается. Попробуем получить предсказания на основе тестовой выборки:

y_pred = model.predict(x_test)

А как узнать, что такая модель лучшая из всех доступных? Нужно воспользоваться метриками качества.

Метрики качества для оценки работоспособности модели

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

   

Абсолютная опускает возведение в квадрат:

   

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

y_test = np.exp(y_test)
y_pred = np.exp(y_pred)

В модуле metrics имеется соответственно mean_squared_error, mean_absolute_error:

from sklearn.metrics import mean_squared_error
from sklearn.metrics import mean_absolute_error

mse = mean_squared_error(y_test, y_pred)
mae = mean_absolute_error(y_test, y_pred)
print('mse: %.3f, mae: %.3f' % (mse, mae))

В результате мы получили соответствующие результаты:

mse: 33213.153, mae: 63.478

Абсолютная ошибка составляет $63, a если взять корень от среднеквадратической ошибки, то получится $182. В целом, это большие значения, особенно с перерасчетом в рубли. Что можно сделать, чтобы улучшить модель? Здесь можно применить следующее:

  • Использовать другие модели MachineLearning, в Scikit-learn их огромное количество [2];
  • отфильтровать данные, например, взять только те места, в которых можно остаться только на 1-2 ночи или, наоборот, на 1 месяц;
  • добавить дополнительные признаки.

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

 
 
Как эффективно решать задачи линейной регрессии, а также работать с другими методами Machine Learning с помощью Python, вы узнаете на практических курсах для специалистов Big Data в нашем лицензированном учебном центре обучения и повышения квалификации ИТ-специалистов в Москве.

Источники

  1. https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  2. https://scikit-learn.org/stable/modules/classes.html

Python | Линейная регрессия с использованием склеарна

Условие: линейная регрессия

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

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

В этой демонстрации модель будет использовать Gradient Descent для обучения. Вы можете узнать об этом здесь.

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

import numpy as np

import pandas as pd

import seaborn as sns

import matplotlib.pyplot as plt

from sklearn import preprocessing, svm

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LinearRegression

Шаг 2: Чтение набора данных

Вы можете скачать набор данных здесь.

cd C:\Users\Dev\Desktop\Kaggle\Salinity

  

df = pd.read_csv('bottle.csv')

df_binary = df[['Salnty', 'T_degC']]

  

df_binary.columns = ['Sal', 'Temp']

  
df_binary.head()

  

Шаг 3: Изучение разброса данных

sns.lmplot(x ="Sal", y ="Temp", data = df_binary, order = 2, ci = None)

  

Шаг 4: Очистка данных

df_binary.fillna(method ='ffill', inplace = True)

Шаг 5: Обучение нашей модели

X = np.array(df_binary['Sal']).reshape(-1, 1)

y = np.array(df_binary['Temp']).reshape(-1, 1)

  

df_binary.dropna(inplace = True)

  

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25)

  

regr = LinearRegression()

  
regr.fit(X_train, y_train)

print(regr.score(X_test, y_test))

Шаг 6: Изучение наших результатов

y_pred = regr.predict(X_test)

plt.scatter(X_test, y_test, color ='b')

plt.plot(X_test, y_pred, color ='k')

  
plt.show()

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

Шаг 7: Работа с меньшим набором данных

df_binary500 = df_binary[:][:500]

  

sns.lmplot(x ="Sal", y ="Temp", data = df_binary500,

                               order = 2, ci = None)

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

df_binary500.fillna(method ='ffill', inplace = True)

  

X = np.array(df_binary500['Sal']).reshape(-1, 1)

y = np.array(df_binary500['Temp']).reshape(-1, 1)

  

df_binary500.dropna(inplace = True)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25)

  

regr = LinearRegression()

regr.fit(X_train, y_train)

print(regr.score(X_test, y_test))

y_pred = regr.predict(X_test)

plt.scatter(X_test, y_test, color ='b')

plt.plot(X_test, y_pred, color ='k')

  
plt.show()

Рекомендуемые посты:

Python | Линейная регрессия с использованием склеарна

0.00 (0%) 0 votes

Страница не найдена · GitHub Pages

Страница не найдена · GitHub Pages

Файл не найден

Сайт, настроенный по этому адресу, не
содержать запрошенный файл.

Если это ваш сайт, убедитесь, что регистр имени файла соответствует URL-адресу.
Для корневых URL (например, http://example.com/ ) вы должны предоставить
index.html файл.

Прочтите полную документацию
для получения дополнительной информации об использовании GitHub Pages .

.

Страница не найдена · GitHub Pages

Страница не найдена · GitHub Pages

Файл не найден

Сайт, настроенный по этому адресу, не
содержать запрошенный файл.

Если это ваш сайт, убедитесь, что регистр имени файла соответствует URL-адресу.
Для корневых URL (например, http://example.com/ ) вы должны предоставить
index.html файл.

Прочтите полную документацию
для получения дополнительной информации об использовании GitHub Pages .

.

Страница не найдена · GitHub Pages

Страница не найдена · GitHub Pages

Файл не найден

Сайт, настроенный по этому адресу, не
содержать запрошенный файл.

Если это ваш сайт, убедитесь, что регистр имени файла соответствует URL-адресу.
Для корневых URL (например, http://example.com/ ) вы должны предоставить
index.html файл.

Прочтите полную документацию
для получения дополнительной информации об использовании GitHub Pages .

.

Страница не найдена · GitHub Pages

Страница не найдена · GitHub Pages

Файл не найден

Сайт, настроенный по этому адресу, не
содержать запрошенный файл.

Если это ваш сайт, убедитесь, что регистр имени файла соответствует URL-адресу.
Для корневых URL (например, http://example.com/ ) вы должны предоставить
index.html файл.

Прочтите полную документацию
для получения дополнительной информации об использовании GitHub Pages .

.

Добавить комментарий

Ваш адрес email не будет опубликован.