Полное подробное руководство по линейной регрессии в Python для начинающих
Реализация базовой, простой и множественной линейной регрессии линейной регрессии в Scikit-Learn
Линейная регрессия — это самый простой тип машинного обучения. Он основан на простой формуле прямой линии, которую мы все выучили в средней школе. Хотя существует множество других более сложных и эффективных алгоритмов машинного обучения, тем не менее, для начала неплохо изучить линейную регрессию. Потому что многие другие популярные алгоритмы машинного обучения и глубокого обучения построены на линейной регрессии.
В этой статье:
1. Мы поговорим о том, как работает линейная регрессия
2. Работайте над простой задачей линейной регрессии, используя библиотеку Python scikit-learn.
3. Работайте над задачей множественной линейной регрессии, используя реальный набор данных в библиотеке Scikit-learn.
Если вы хотите увидеть, как разработать линейную регрессию с нуля на простом Python без какой-либо библиотеки, посмотрите ссылки в конце этой страницы.
Предпосылки
Ожидается, что вы знаете Python хотя бы на начальном уровне. Кроме того, необходимо знать библиотеку Pandas и Matplotlib для начинающих, чтобы начать работу с машинным обучением.
Что такое линейная регрессия?
Говоря простым языком, линейная регрессия описывает взаимосвязь между зависимыми и независимыми переменными. Он описывает взаимосвязь, подгоняя прямую линию. Вот почему это линейная регрессия. Давайте разберемся с этим, используя набор данных. Посмотрите на этот набор данных, где у нас есть две переменные: вес (фунты) и рост (дюймы).
Давайте построим их, поместив Weight в направлении X и Height в направлении y.
Получаем точки. Затем, если мы проведем через точки прямую линию, которая лучше всего соответствует точкам, мы сможем предсказать высоту, если у нас есть информация о весе. Например, если вес составляет 160 фунтов, мы можем просто провести прямую линию из 160 точек и провести еще одну прямую линию из той же точки от прямой до оси Y, как показано на рисунке ниже. Таким образом, мы можем найти высоту (дюймы), которая составляет около 66 дюймов.
Здесь Вес — независимая переменная, а Рост — зависимая переменная.
Вот прямолинейная формула для освежения:
Y = mX + C
Где,
Y — зависимая переменная (на рисунке выше высота — это Y)
X — независимая переменная (на рисунке выше вес — это X)
m - наклон прямой линии
C - Y-перехват
Задача линейной регрессии будет заключаться в том, чтобы найти «m» и «C», чтобы прямая линия лучше всего представляла все точки. Итак, m и C называются параметрами обучения для линейной регрессии. Для разных алгоритмов машинного обучения параметры обучения разные.
Вот видеоверсия основ линейной регрессии:
Допущения в линейной регрессии
- Наблюдения независимы: ожидается, что наблюдения в наборе данных сделаны с использованием действительного метода выборки, и они независимы друг от друга.
- Линейная корреляция. Для работы линейной регрессии также необходимо, чтобы зависимая переменная и независимая переменная были линейно коррелированы, как показано на рисунке выше. Если нет, то нам нужно попробовать другие методы машинного обучения.
3. Нормальность: данные подчиняются нормальному распределению. Хотя, если у нас есть достаточно большой набор данных, мы больше не беспокоимся о нормальности.
Пример простой линейной регрессии
Давайте поработаем на примере. В этом примере я буду использовать этот знаменитый набор данных «радужная оболочка» от Seaborn. Для этого мне нужно сначала импортировать библиотеку Seaborn. Затем используйте функцию load_dataset из библиотеки seaborn, чтобы загрузить набор данных радужной оболочки.
import seaborn as sns
iris = sns.load_dataset('iris')
iris
Как видите, в наборе данных iris есть несколько переменных. Для простой линейной регрессии нам нужны только две переменные, я оставлю здесь только лепесток_длины и лепестка_ширины.
iris = iris[['petal_length', 'petal_width']]
Вот как теперь выглядит набор данных радужной оболочки:
Давайте рассмотрим длину лепестка как независимую переменную, а ширину лепестка — как зависимую переменную. Если мы сравним это с формулой прямой линии, которую мы обсуждали выше, длина лепестка — это X, а ширина лепестка — это «у».
X = iris['petal_length'] y = iris['petal_width']
Прежде чем погрузиться в линейную регрессию, мы должны проверить, линейно ли коррелируют наши X и y. Я буду использовать библиотеку Matplotlib для создания точечной диаграммы:
import matplotlib.pyplot as plt
plt.scatter(X, y)
plt.xlabel("petal length")
plt.ylabel("petal width")
Он показывает, что связь между переменными является линейной.
В машинном обучении мы не используем весь набор данных для разработки модели. Мы разделили набор данных на две части. Одна часть предназначена для построения модели, которая называется обучающим набором, а другая часть предназначена для оценки модели, которая называется набором тестовых данных.
Важно сохранить часть набора данных для целей тестирования. Потому что наша цель — построить модель, которая обобщает и хорошо работает с данными, которые модель раньше не видела.
Для этого мы будем использовать метод train_test_split из библиотеки scikit-learn.
from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.4, random_state = 23)
Здесь test_size 0.4 означает, что он сохранит 40% данных для целей тестирования.
random_state = 23 означает, что если мы используем тот же набор данных и используем random_state 23, он снова создаст тот же самый сплит-тест поезда. Random_state может быть любым другим целым числом.
Давайте посмотрим на X_train:
X_train
Выход:
77 5.0
29 1.6
92 4.0
23 1.7
128 5.6
...
39 1.5
91 4.6
31 1.5
40 1.3
83 5.1
Name: petal_length, Length: 90, dtype: float64
Как видите, X_train — это одномерный ряд. Модели машинного обучения в библиотеке sklearn используют двумерные данные для обучения функциям. Таким образом, X всегда должен быть двумерным, а y должен быть одномерным.
Итак, нам нужно сделать наш X двумерным. Это можно сделать с помощью этого простого кода:
import numpy as np X_train = np.array(X_train).reshape(-1, 1) X_train
Вот часть X_train сейчас:
array([[5. ],
[1.6],
[4. ],
[1.7],
[5.6],
[4. ],
[4.8],
[5.6],
[5.1],
[4.9],
[1.4],
[1.6],
[5.6],
[1.4],
[1.6],
[5.5],
[5.1],
[4. ],
[1.4],
Нам нужно изменить X_test таким же образом:
X_test = np.array(X_test).reshape(-1, 1) X_test
Выход:
array([[5.4],
[6. ],
[4.1],
[1.5],
[5. ],
[4.9],
[1.7],
[5.5],
[1.7],
[3.6],
[4.7],
[1.6],
[5.9],
[1.5],
[1.5],
[5.1],
[4.5],
[4.7],
[6.1],
[1.4],
[5.3],
[1.4],
[1.6],
[1.3],
[5.6],
Наши данные готовы. Сначала нам нужно импортировать модель линейной регрессии из библиотеки scikit-learn.
from sklearn.linear_model import LinearRegression
Я сохраню экземпляр модели в переменной:
lr = LinearRegression()
Следующим шагом является подгонка обучающих данных к модели линейной регрессии.
lr.fit(X_train, y_train)
Подгонка модели выполнена. У нас должны быть параметры обучения m и C. Вот перехват C:
c = lr.intercept_ c
Выход:
-0.3511327422143744
В языке машинного обучения мы не используем термин наклон. Вместо этого он известен как коэффициент X. Вот коэффициент для этой модели:
m = lr.coef_ m
Выход:
array([0.41684538])
Теперь мы можем использовать формулу прямой линии, чтобы предсказать «y», используя X. Поскольку наш X двумерный, выходные данные будут двумерными. Я сплющу вывод, чтобы сделать его одномерным, чтобы показать вам:
Y_pred_train = m*X_train + c Y_pred_train.flatten()
Выход:
array([1.73309416, 0.31581987, 1.31624878, 0.3575044 , 1.98320139,
1.31624878, 1.64972508, 1.98320139, 1.7747787 , 1.69140962,
0.23245079, 0.31581987, 1.98320139, 0.23245079, 0.31581987,
1.94151685, 1.7747787 , 1.31624878, 0.23245079, 1.35793332,
1.85814777, 1.52467147, 2.06657046, 2.40004677, 1.44130239,
0.19076625, 1.31624878, 1.69140962, 1.69140962, 1.31624878,
0.27413533, 1.52467147, 1.52467147, 1.27456424, 1.73309416,
1.64972508, 1.2328797 , 1.7747787 , 2.27499315, 2.19162408,
0.14908171, 2.02488593, 0.8994034 , 0.27413533, 2.108255 ,
1.64972508, 0.23245079, 1.52467147, 1.39961786, 1.81646324,
0.19076625, 0.06571264, 1.10782609, 0.10739718, 1.60804055,
1.39961786, 0.14908171, 2.06657046, 1.44130239, 1.52467147,
0.31581987, 2.52510038, 1.56635601, 1.7747787 , 1.98320139,
1.60804055, 0.27413533, 0.31581987, 1.94151685, 2.06657046,
1.48298693, 0.19076625, 1.81646324, 1.02445701, 2.02488593,
1.10782609, 0.19076625, 0.27413533, 0.27413533, 1.7747787 ,
0.23245079, 0.23245079, 1.69140962, 0.23245079, 1.48298693,
0.27413533, 1.56635601, 0.27413533, 0.19076625, 1.7747787 ])
Вот прогнозируемый результат с использованием параметра обучения, который мы нашли в модели.
Но нам не нужно использовать параметры обучения и вычислять результат по формуле. Мы можем просто использовать метод прогнозирования, чтобы сделать это:
y_pred_train1 = lr.predict(X_train) y_pred_train1
Выход:
array([1.73309416, 0.31581987, 1.31624878, 0.3575044 , 1.98320139,
1.31624878, 1.64972508, 1.98320139, 1.7747787 , 1.69140962,
0.23245079, 0.31581987, 1.98320139, 0.23245079, 0.31581987,
1.94151685, 1.7747787 , 1.31624878, 0.23245079, 1.35793332,
1.85814777, 1.52467147, 2.06657046, 2.40004677, 1.44130239,
0.19076625, 1.31624878, 1.69140962, 1.69140962, 1.31624878,
0.27413533, 1.52467147, 1.52467147, 1.27456424, 1.73309416,
1.64972508, 1.2328797 , 1.7747787 , 2.27499315, 2.19162408,
0.14908171, 2.02488593, 0.8994034 , 0.27413533, 2.108255 ,
1.64972508, 0.23245079, 1.52467147, 1.39961786, 1.81646324,
0.19076625, 0.06571264, 1.10782609, 0.10739718, 1.60804055,
1.39961786, 0.14908171, 2.06657046, 1.44130239, 1.52467147,
0.31581987, 2.52510038, 1.56635601, 1.7747787 , 1.98320139,
1.60804055, 0.27413533, 0.31581987, 1.94151685, 2.06657046,
1.48298693, 0.19076625, 1.81646324, 1.02445701, 2.02488593,
1.10782609, 0.19076625, 0.27413533, 0.27413533, 1.7747787 ,
0.23245079, 0.23245079, 1.69140962, 0.23245079, 1.48298693,
0.27413533, 1.56635601, 0.27413533, 0.19076625, 1.7747787 ])
Давайте проверим, верен ли прогноз на самом деле. Мы можем проверить с помощью визуализации. Я добавлю линейный график X и прогнозируемое значение «y» на точечную диаграмму «petal_length» и «petal_width» выше.
import matplotlib.pyplot as plt
plt.scatter(X_train, y_train)
plt.plot(X_train, y_pred_train1, color ='red')
plt.xlabel("petal length")
plt.ylabel("petal width")
Как видно на этой картинке, предсказанная буква «y» очень хорошо соответствует точкам! Но мы сделали прогноз, используя обучающие данные, и наша модель обучена на обучающих данных.
Нашей целью было обучить модель, чтобы она могла работать и с другими данными, а не только с теми же обучающими данными. Вот почему мы сохранили тестовые данные, чтобы проверить, работает ли модель с тестовыми данными. также.
Итак, здесь я буду использовать X_test для предсказания y_test.
y_pred_test1 = lr.predict(X_test) y_pred_test1
Выход:
array([1.89983231, 2.14993954, 1.35793332, 0.27413533, 1.73309416,
1.69140962, 0.3575044 , 1.94151685, 0.3575044 , 1.14951063,
1.60804055, 0.31581987, 2.108255 , 0.27413533, 0.27413533,
1.7747787 , 1.52467147, 1.60804055, 2.19162408, 0.23245079,
1.85814777, 0.23245079, 0.31581987, 0.19076625, 1.98320139,
0.23245079, 0.44087348, 1.64972508, 1.48298693, 1.27456424,
0.27413533, 1.27456424, 0.19076625, 2.44173131, 0.27413533,
0.3575044 , 1.56635601, 1.02445701, 1.39961786, 2.14993954,
2.02488593, 0.44087348, 1.19119517, 0.23245079, 1.48298693,
1.73309416, 1.52467147, 2.31667769, 0.27413533, 1.35793332,
2.19162408, 1.89983231, 0.23245079, 1.98320139, 1.52467147,
1.60804055, 2.44173131, 1.39961786, 0.23245079, 1.7747787 ])
Мы должны проверить, соответствует ли этот прогноз точкам и данным обучения:
import matplotlib.pyplot as plt
plt.scatter(X_test, y_test)
plt.plot(X_test, y_pred_test1, color ='red')
plt.xlabel("petal length")
plt.ylabel("petal width")
Как видите, предсказанный «y» довольно хорошо соответствует данным. Теперь, если у нас есть длина лепестка, мы сможем предсказать ширину лепестка, используя эту модель. Предсказанный лепесток_ширина может не совпадать с оригиналом. Но это должно быть достаточно близко.
Это видеоверсия учебника по простой линейной регрессии:
Пример множественной линейной регрессии
В последнем примере у нас была только одна переменная для предсказания ширины лепестка. Но в реальном мире большую часть времени мы работаем с несколькими тренировочными функциями. Здесь мы будем работать над проектом, который будет напоминать реальный проект.
Для этой демонстрации мы будем использовать набор страховых данных от Kaggle. Пожалуйста, не стесняйтесь загружать набор данных по этой ссылке:
В этом наборе данных у нас всего 7 столбцов. Давайте сначала посмотрим на набор данных:
import pandas as pd
df = pd.read_csv('insurance.csv')
df
Вот набор страховых данных, где последний столбец — это расходы, а у нас есть еще 6 столбцов. Задача будет заключаться в том, чтобы использовать 6 других столбцов для прогнозирования расходов. Эти шесть других столбцов мы называем функциями или переменными.
Как работает формула линейной регрессии для такого количества функций?
Когда у нас есть несколько функций, формула прямой линии Y = mX + C становится такой:
Y = m1X1 + m2X2 + m3X3 + …. mnXn
Как видно из формулы, каждому признаку соответствует свой коэффициент. Итак, в этом проекте у нас есть 6 признаков и у нас также будет 6 коэффициентов.
Мы не можем построить график «у» в зависимости от X, как мы это делали для простой линейной регрессии. Потому что у нас сейчас так много переменных. Таким образом, это уже не двухмерное изображение. У него так много измерений.
Если вы посмотрите на набор данных, в нем есть несколько категориальных переменных со строковыми значениями. Алгоритмы машинного обучения в библиотеке sklearn не могут обрабатывать строковые значения. Ему нужны числовые значения. Итак, я преобразую эти категориальные значения в числовые значения.
df['sex'] =df['sex'].astype('category')
df['sex'] = df['sex'].cat.codes
df['smoker'] =df['smoker'].astype('category')
df['smoker'] = df['smoker'].cat.codes
df['region'] =df['region'].astype('category')
df['region'] = df['region'].cat.codes
Посмотрите на «df» сейчас. Функция «пол» представляла собой категориальную переменную со значениями «мужской» или «женский». Теперь они стали 1 или 0. Таким же образом были изменены и другие категориальные переменные.
Это также хорошая идея, чтобы проверить, есть ли у нас нулевые значения. Потому что если у нас есть нулевые значения в данных, мы получим ошибки при обучении модели.
df.isnull().sum()
Выход:
age 0 sex 0 bmi 0 children 0 smoker 0 region 0 charges 0 dtype: int64
У нас нет нулевых значений ни в одном из столбцов.
Теперь разделите X и Y. Поскольку мы будем использовать 6 других переменных для прогнозирования «зарядов», наш X будет состоять из всех 6 переменных. Из набора данных, если мы удалим столбец «цена», мы получим наш X:
X = df.drop(columns = 'charges') X
Поскольку мы будем предсказывать «цену», нашим «y» будет столбец «цена».
y = df['charges']
Использование 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.3, random_state = 23)
Мы уже импортировали модель линейной регрессии ранее. Итак, мы можем просто использовать его сейчас. Теперь я сохраню модель линейной регрессии в другой переменной с именем lr_multiple и подгоню данные обучения к модели.
lr_multiple = LinearRegression() lr_multiple.fit(X_train, y_train)
Проводится обучение моделей. Давайте теперь посмотрим на параметры обучения. Вот перехват:
c = lr_multiple.intercept_ c
Выход:
-11827.733141795668
Наклоны или коэффициенты:
m = lr_multiple.coef_ m
Выход:
array([ 256.5772619 , -49.39232379, 329.02381564, 479.08499828, 23400.28378787, -276.31576201])
Мы получили наши 6 коэффициентов, как я упоминал ранее.
Давайте спрогнозируем цену как для данных обучения, так и для данных тестирования:
y_pred_train = lr_multiple.predict(X_train) y_pred_test = lr_multiple.predict(X_test)
На этот раз мы не будем рисовать, так как у нас есть 6 функций. Но я представлю другой метод оценки. Это оценка R2.
Оценка R2 указывает на качество соответствия. Он показывает, насколько хорошо ваши обучающие функции могут объяснить дисперсию в метке. Значение может лежать в диапазоне от 0 до 1. Чем ближе r2_score к 1, тем выше производительность модели.
Нам нужно сначала импортировать r2_score, а затем вычислить r2_score. Он принимает исходные значения «y» и предсказанные значения «y». Поскольку мы прогнозируем для тестовых данных, исходные значения будут y_test:
from sklearn.metrics import r2_score r2_score(y_test, y_pred_test)
Выход:
0.7911113876316933
Наш r2_score равен 0,79. Так что можно сказать, что модель довольно крепкая.
Вот ссылка на видеоверсию учебника по множественной линейной регрессии:
Заключение
Надеюсь, это была хорошая отправная точка для вас. Если вас больше интересует разработка линейной регрессии и других популярных алгоритмов машинного обучения с нуля, перейдите по этой ссылке:
Я надеюсь, что это было полезно.
Не стесняйтесь подписываться на меня в Twitter и лайкать мою страницу Facebook.
Подробнее Чтение
Обзор предложений и функций SQL Query
Можно использовать в качестве шпаргалки по SQLpub.towardsai.net
