Получить профессию в Skypro
Линейная регрессия в Python: от теории к практическому применению
Для кого эта статья:
- Студенты и начинающие специалисты в области аналитики данных и машинного обучения
- Практикующие аналитики и дата-сайентисты, желающие углубить свои знания в линейной регрессии
Преподаватели и обучающие курсы по статистике и машинному обучению
Линейная регрессия — краеугольный камень машинного обучения, который позволяет расшифровать сложные зависимости в данных через элегантную математическую модель. Освоив этот алгоритм в Python, вы получите мощный инструмент предсказания числовых показателей и оценки влияния факторов на целевую переменную. Неважно, анализируете ли вы финансовые тренды, прогнозируете продажи или оцениваете зависимость веса от роста — линейная регрессия даст точный ответ, основанный на статистически значимых закономерностях. 📊🐍
Хотите уверенно применять линейную регрессию в реальных проектах и стать востребованным аналитиком данных? Курс Профессия аналитик данных от Skypro даст вам не только теоретические знания, но и практические навыки построения предиктивных моделей. Вы научитесь профессионально готовить данные, выбирать оптимальные алгоритмы и интерпретировать результаты под руководством опытных менторов, работающих в индустрии. Ваше резюме с реальными проектами не останется без внимания работодателей!
Что такое линейная регрессия и как она работает
Линейная регрессия — это алгоритм машинного обучения, позволяющий моделировать зависимость между входными переменными (признаками) и выходной переменной (целью) через линейную функцию. По сути, алгоритм пытается провести прямую линию через облако точек данных таким образом, чтобы минимизировать среднеквадратичную ошибку — расстояние между предсказанными и фактическими значениями.
Математически модель простой линейной регрессии можно представить так:
y = β₀ + β₁x + ε
Где:
- y — зависимая переменная (целевая)
- x — независимая переменная (признак)
- β₀ — свободный член (пересечение с осью Y)
- β₁ — коэффициент наклона
- ε — случайная ошибка
Для множественной линейной регрессии формула расширяется до:
y = β₀ + β₁x₁ + β₂x₂ + ... + βₙxₙ + ε
Алексей Петров, руководитель аналитического отдела
Однажды наша компания столкнулась с необходимостью прогнозировать цены на жилье в различных районах города. У нас была база данных с информацией о сотнях объектов недвижимости: площадь, количество комнат, этаж, расстояние до центра города и, конечно, цена. Ранее мы пользовались примитивным подходом, где средняя цена за квадратный метр умножалась на площадь объекта с небольшими поправками.
Применив линейную регрессию в Python, мы смогли построить модель, которая учитывала все перечисленные факторы и их сложные взаимосвязи. Результат превзошёл ожидания — точность прогнозов выросла на 27%, а клиенты стали получать гораздо более реалистичные оценки стоимости своей недвижимости. Особенно ценным оказалось то, что модель позволила численно оценить влияние каждого фактора. Например, мы выяснили, что наличие парка в радиусе 500 метров увеличивает стоимость квартиры в среднем на 8%, а близость к станции метро — на 15%.
Ключевые преимущества линейной регрессии:
- Интерпретируемость — легко объяснить влияние каждого признака на целевую переменную
- Вычислительная эффективность — быстро обучается даже на больших наборах данных
- Устойчивость — при правильной регуляризации не склонна к переобучению
- Статистическая значимость — можно оценить достоверность влияния факторов
Однако у линейной регрессии есть и ограничения — она предполагает линейную зависимость между переменными и чувствительна к выбросам в данных. Также эффективность модели может снизиться при наличии мультиколлинеарности (высокой корреляции между признаками).
| Допущение | Описание | Последствия нарушения |
|---|---|---|
| Линейность | Зависимость между X и Y должна быть линейной | Систематическая ошибка в предсказаниях |
| Независимость ошибок | Остатки модели не должны коррелировать | Неверные оценки стандартных ошибок |
| Гомоскедастичность | Постоянная дисперсия остатков | Неэффективность оценок коэффициентов |
| Нормальность ошибок | Остатки должны иметь нормальное распределение | Проблемы при статистическом выводе |
Подготовка данных для линейной регрессии в Python
Качество модели линейной регрессии напрямую зависит от корректной подготовки данных. Этот этап критически важен, так как "мусор на входе – мусор на выходе". Рассмотрим последовательность шагов, необходимых для трансформации сырых данных в формат, оптимальный для построения регрессионной модели. 🧹🔍
Сначала импортируем необходимые библиотеки:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
Загрузка и первичный осмотр данных:
# Загрузка данных
df = pd.read_csv('housing_data.csv')
# Первичный осмотр
print(df.head())
print(df.info())
print(df.describe())
# Проверка пропущенных значений
print(df.isnull().sum())
Ключевые шаги подготовки данных:
- Обработка пропущенных значений
# Заполнение пропусков медианой для числовых признаков
df['income'] = df['income'].fillna(df['income'].median())
# Или удаление строк с пропусками (если их мало)
df = df.dropna()
- Обработка выбросов
# Выявление выбросов через межквартильный размах
Q1 = df['price'].quantile(0.25)
Q3 = df['price'].quantile(0.75)
IQR = Q3 – Q1
lower_bound = Q1 – 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR
# Фильтрация выбросов
df_filtered = df[(df['price'] >= lower_bound) & (df['price'] <= upper_bound)]
- Кодирование категориальных переменных
# One-hot кодирование
df_encoded = pd.get_dummies(df, columns=['neighborhood'], drop_first=True)
- Масштабирование признаков
# Стандартизация числовых признаков
scaler = StandardScaler()
numeric_features = ['square_feet', 'bedrooms', 'bathrooms', 'age']
df[numeric_features] = scaler.fit_transform(df[numeric_features])
- Проверка корреляций и мультиколлинеарности
# Построение корреляционной матрицы
correlation_matrix = df[numeric_features + ['price']].corr()
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm')
plt.show()
- Разделение на обучающую и тестовую выборки
# Определение признаков и целевой переменной
X = df.drop('price', axis=1)
y = df['price']
# Разделение данных
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
Мария Соколова, дата-сайентист
Работая с проектом по прогнозированию энергопотребления в жилых домах, я столкнулась с классической проблемой "грязных данных". Наши датчики собирали информацию о температуре, влажности, времени суток и количестве людей в помещении. Первоначальная модель линейной регрессии показывала неутешительные результаты — R² всего 0.48.
Вместо того, чтобы сразу переходить к более сложным моделям, я решила тщательнее подготовить данные. Выяснилось, что в выходные дни характер потребления кардинально отличался, а значения температуры содержали систематические ошибки измерения в ночное время. После создания бинарного признака "выходной/будний" и коррекции температурных данных, а также логарифмирования целевой переменной (энергопотребление имело логнормальное распределение), точность той же линейной модели выросла до R² = 0.87! Это напомнило мне важный урок: качественная подготовка данных часто важнее усложнения модели.
Важные рекомендации при подготовке данных для линейной регрессии:
- Проверяйте распределение целевой переменной — если оно сильно скошено, рассмотрите логарифмирование или другие преобразования
- Анализируйте влиятельные наблюдения — точки с высоким рычагом (leverage) могут значительно искажать модель
- Оценивайте мультиколлинеарность — высококоррелированные признаки могут дестабилизировать оценки коэффициентов
- Создавайте информативные признаки — иногда нелинейные преобразования или взаимодействия признаков могут улучшить линейную модель
| Проблема | Решение | Функции Python |
|---|---|---|
| Пропущенные значения | Заполнение медианой/средним или удаление | fillna(), dropna() |
| Выбросы | Винзоризация или удаление по IQR | quantile(), clip() |
| Категориальные переменные | One-hot кодирование или Label Encoding | get_dummies(), LabelEncoder |
| Разный масштаб признаков | Стандартизация или нормализация | StandardScaler, MinMaxScaler |
| Скошенное распределение | Логарифмирование, Box-Cox трансформация | np.log(), boxcox() |
Реализация простой линейной регрессии с scikit-learn
После тщательной подготовки данных можно приступать к построению модели простой линейной регрессии. Библиотека scikit-learn предоставляет мощный и интуитивно понятный инструментарий для этой задачи. Рассмотрим реализацию пошагово на конкретном примере прогнозирования цен на недвижимость в зависимости от площади. 📈🧠
Начнем с импорта необходимых компонентов:
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
Создадим или загрузим данные для анализа:
# Пример загрузки данных
df = pd.read_csv('housing.csv')
# Для демонстрации создадим синтетический набор данных
# np.random.seed(42)
# area = np.random.randint(30, 300, 100)
# price = 50000 + 1500 * area + np.random.normal(0, 20000, 100)
# df = pd.DataFrame({'area': area, 'price': price})
Визуализируем данные для понимания зависимости:
plt.figure(figsize=(10, 6))
plt.scatter(df['area'], df['price'], alpha=0.7)
plt.title('Зависимость цены от площади')
plt.xlabel('Площадь, м²')
plt.ylabel('Цена, руб.')
plt.grid(True, alpha=0.3)
plt.show()
Подготовим данные для модели:
# Выделяем признак (X) и целевую переменную (y)
X = df[['area']] # Обратите внимание на двойные скобки – необходимы для сохранения формата DataFrame
y = df['price']
# Разделяем данные на обучающую и тестовую выборки
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, random_state=42)
Теперь создадим, обучим и используем модель линейной регрессии:
# Создание экземпляра модели
model = LinearRegression()
# Обучение модели на тренировочных данных
model.fit(X_train, y_train)
# Получение коэффициентов модели
print(f'Коэффициент наклона (β₁): {model.coef_[0]:.2f}')
print(f'Свободный член (β₀): {model.intercept_:.2f}')
# Делаем предсказания
y_pred_train = model.predict(X_train)
y_pred_test = model.predict(X_test)
# Оцениваем качество модели
train_rmse = np.sqrt(mean_squared_error(y_train, y_pred_train))
test_rmse = np.sqrt(mean_squared_error(y_test, y_pred_test))
train_r2 = r2_score(y_train, y_pred_train)
test_r2 = r2_score(y_test, y_pred_test)
print(f'RMSE на обучающей выборке: {train_rmse:.2f}')
print(f'RMSE на тестовой выборке: {test_rmse:.2f}')
print(f'R² на обучающей выборке: {train_r2:.4f}')
print(f'R² на тестовой выборке: {test_r2:.4f}')
Визуализируем результаты модели:
# Создаем диапазон значений для построения линии регрессии
x_range = np.linspace(X['area'].min(), X['area'].max(), 100).reshape(-1, 1)
y_range = model.predict(x_range)
plt.figure(figsize=(10, 6))
plt.scatter(X_train, y_train, alpha=0.7, label='Обучающие данные')
plt.scatter(X_test, y_test, alpha=0.7, color='orange', label='Тестовые данные')
plt.plot(x_range, y_range, color='red', linewidth=2, label='Линия регрессии')
plt.title('Модель линейной регрессии')
plt.xlabel('Площадь, м²')
plt.ylabel('Цена, руб.')
plt.grid(True, alpha=0.3)
plt.legend()
plt.show()
Применим модель для прогнозирования цены по новым значениям площади:
# Прогнозирование для новых данных
new_areas = np.array([[50], [100], [150], [200]])
predicted_prices = model.predict(new_areas)
for area, price in zip(new_areas, predicted_prices):
print(f'Для площади {area[0]} м² предсказанная цена: {price:.2f} руб.')
Использование модели линейной регрессии в scikit-learn можно обобщить в следующие ключевые шаги:
- Подготовка данных — очистка, масштабирование, разделение на обучающую и тестовую выборки
- Создание и обучение модели — инициализация объекта LinearRegression и вызов метода fit()
- Анализ коэффициентов — изучение весов признаков через coef и intercept
- Оценка производительности — расчет метрик качества, таких как RMSE, MAE и R²
- Применение модели — прогнозирование на новых данных с помощью predict()
Дополнительные рекомендации для работы с линейной регрессией в scikit-learn:
- Используйте crossvalscore() для более надежной оценки модели через кросс-валидацию
- Примените traintestsplit() с параметром stratify для сохранения распределения в выборках, если это критично
- Рассмотрите регуляризованные версии регрессии (Ridge, Lasso), если столкнулись с переобучением
- Используйте Pipeline для автоматизации последовательной обработки данных и построения модели
Множественная линейная регрессия в Python на практике
Множественная линейная регрессия расширяет концепцию простой линейной регрессии, позволяя использовать несколько независимых переменных для прогнозирования. Это особенно полезно в реальных задачах, где целевая переменная зависит от множества факторов. Рассмотрим практическую реализацию в Python на примере прогнозирования стоимости недвижимости. 🏙️🔢
Сначала импортируем необходимые библиотеки:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, r2_score
import statsmodels.api as sm
Загрузим и подготовим данные:
# Загрузка данных (пример с набором данных о жилье в Бостоне)
from sklearn.datasets import load_boston
boston = load_boston()
df = pd.DataFrame(boston.data, columns=boston.feature_names)
df['PRICE'] = boston.target
# Краткий обзор данных
print(df.head())
print(df.describe())
# Визуализация корреляции между переменными
plt.figure(figsize=(12, 10))
sns.heatmap(df.corr(), annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Корреляционная матрица')
plt.show()
Подготовим данные для обучения модели:
# Разделение данных на признаки и целевую переменную
X = df.drop('PRICE', axis=1)
y = df['PRICE']
# Стандартизация признаков
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
X_scaled_df = pd.DataFrame(X_scaled, columns=X.columns)
# Разделение на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X_scaled_df, y, test_size=0.2, random_state=42)
Создадим и обучим модель множественной линейной регрессии:
# Создание и обучение модели с помощью scikit-learn
model = LinearRegression()
model.fit(X_train, y_train)
# Анализ коэффициентов модели
coefficients = pd.DataFrame({'Feature': X.columns, 'Coefficient': model.coef_})
coefficients = coefficients.sort_values('Coefficient', ascending=False)
print("Коэффициенты модели:")
print(coefficients)
print(f"Свободный член (Intercept): {model.intercept_:.4f}")
# Визуализация влияния признаков
plt.figure(figsize=(12, 8))
sns.barplot(x='Coefficient', y='Feature', data=coefficients)
plt.title('Влияние признаков на цену')
plt.tight_layout()
plt.show()
Оценим качество модели:
# Предсказание на обучающей и тестовой выборках
y_train_pred = model.predict(X_train)
y_test_pred = model.predict(X_test)
# Расчет метрик качества
train_rmse = np.sqrt(mean_squared_error(y_train, y_train_pred))
test_rmse = np.sqrt(mean_squared_error(y_test, y_test_pred))
train_r2 = r2_score(y_train, y_train_pred)
test_r2 = r2_score(y_test, y_test_pred)
print(f"RMSE на обучающей выборке: {train_rmse:.4f}")
print(f"RMSE на тестовой выборке: {test_rmse:.4f}")
print(f"R² на обучающей выборке: {train_r2:.4f}")
print(f"R² на тестовой выборке: {test_r2:.4f}")
Дополнительно используем statsmodels для более детального статистического анализа:
# Добавление константы для свободного члена
X_train_sm = sm.add_constant(X_train)
X_test_sm = sm.add_constant(X_test)
# Обучение модели с помощью statsmodels
model_sm = sm.OLS(y_train, X_train_sm).fit()
# Вывод статистической сводки
print(model_sm.summary())
# Проверка нормальности остатков
residuals = model_sm.resid
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
sns.histplot(residuals, kde=True)
plt.title('Распределение остатков')
plt.subplot(1, 2, 2)
sm.qqplot(residuals, line='45', fit=True)
plt.title('Q-Q график остатков')
plt.tight_layout()
plt.show()
Рассмотрим пример использования модели для предсказания цены конкретного объекта недвижимости:
# Пример предсказания для нового объекта
new_house = pd.DataFrame({
'CRIM': [0\.05], # Уровень преступности
'ZN': [25\.0], # Доля жилых участков
'INDUS': [2\.5], # Доля нежилых земель
'CHAS': [0], # Река Чарльз (0 – нет, 1 – есть)
'NOX': [0\.45], # Концентрация оксидов азота
'RM': [6\.5], # Среднее число комнат
'AGE': [50\.0], # Доля домов до 1940 года
'DIS': [4\.5], # Расстояние до центров занятости
'RAD': [6], # Индекс доступности до радиальных магистралей
'TAX': [300], # Налоговая ставка
'PTRATIO': [15], # Соотношение учеников и учителей
'B': [380], # Доля чернокожего населения
'LSTAT': [10\.5] # Процент населения с низким статусом
})
# Стандартизация нового объекта
new_house_scaled = scaler.transform(new_house)
# Предсказание цены
predicted_price = model.predict(new_house_scaled)
print(f"Предсказанная цена дома: ${predicted_price[0] * 1000:.2f}")
Ключевые аспекты множественной линейной регрессии, которые следует учитывать:
- Мультиколлинеарность — высокая корреляция между признаками может искажать коэффициенты
- Значимость переменных — не все признаки могут быть статистически значимыми
- Выбор признаков — часто требуется отбор наиболее информативных переменных
- Проверка допущений — линейность, гомоскедастичность, нормальность остатков
Существуют различные модификации линейной регрессии для решения специфических проблем:
| Метод | Класс в scikit-learn | Преимущество | Применение |
|---|---|---|---|
| Ridge-регрессия | Ridge | L2-регуляризация для борьбы с мультиколлинеарностью | Когда признаки сильно коррелируют |
| Lasso-регрессия | Lasso | L1-регуляризация для отбора признаков | Когда нужно упростить модель |
| ElasticNet | ElasticNet | Комбинация L1 и L2 регуляризации | Для балансирования между Ridge и Lasso |
| Полиномиальная регрессия | PolynomialFeatures + LinearRegression | Моделирование нелинейных зависимостей | Когда связь между X и Y нелинейна |
Оценка качества и улучшение модели линейной регрессии
Построение модели линейной регрессии — только половина работы. Не менее важно правильно оценить её качество и применить техники для улучшения результатов. В этом разделе рассмотрим метрики оценки, диагностические инструменты и стратегии оптимизации регрессионных моделей. 📊✅
Начнем с основных метрик оценки качества регрессионной модели:
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
import numpy as np
# Предположим, у нас есть модель и предсказания
y_true = y_test # Фактические значения
y_pred = model.predict(X_test) # Предсказанные значения
# Расчет основных метрик
mse = mean_squared_error(y_true, y_pred)
rmse = np.sqrt(mse)
mae = mean_absolute_error(y_true, y_pred)
r2 = r2_score(y_true, y_pred)
adjusted_r2 = 1 – (1 – r2) * (len(y_true) – 1) / (len(y_true) – X_test.shape[1] – 1)
print(f"MSE: {mse:.4f}")
print(f"RMSE: {rmse:.4f}")
print(f"MAE: {mae:.4f}")
print(f"R²: {r2:.4f}")
print(f"Скорректированный R²: {adjusted_r2:.4f}")
Визуализация остатков для диагностики модели:
import matplotlib.pyplot as plt
import seaborn as sns
# Расчет остатков
residuals = y_true – y_pred
standardized_residuals = residuals / np.std(residuals)
# Графики для диагностики
plt.figure(figsize=(18, 12))
# 1. Остатки vs Предсказанные значения
plt.subplot(2, 2, 1)
plt.scatter(y_pred, residuals)
plt.axhline(y=0, color='r', linestyle='-')
plt.xlabel('Предсказанные значения')
plt.ylabel('Остатки')
plt.title('Остатки vs Предсказанные значения')
# 2. Q-Q график для проверки нормальности
plt.subplot(2, 2, 2)
import statsmodels.api as sm
sm.qqplot(standardized_residuals, line='45', fit=True, ax=plt.gca())
plt.title('Q-Q график стандартизированных остатков')
# 3. Гистограмма остатков
plt.subplot(2, 2, 3)
sns.histplot(residuals, kde=True)
plt.xlabel('Остатки')
plt.title('Распределение остатков')
# 4. Масштабированные остатки vs Рычаг
# Требуется расчет влиятельности наблюдений
from sklearn.linear_model import LinearRegression
model = LinearRegression().fit(X_train, y_train)
leverage = np.diag(X_test @ np.linalg.inv(X_train.T @ X_train) @ X_test.T)
plt.subplot(2, 2, 4)
plt.scatter(leverage, standardized_residuals)
plt.axhline(y=0, color='r', linestyle='-')
plt.xlabel('Рычаг (Leverage)')
plt.ylabel('Стандартизированные остатки')
plt.title('Влиятельность наблюдений')
plt.tight_layout()
plt.show()
Кросс-валидация для более надежной оценки модели:
from sklearn.model_selection import cross_val_score, KFold
# Настройка кросс-валидации
kf = KFold(n_splits=5, shuffle=True, random_state=42)
model = LinearRegression()
# Проведение кросс-валидации с разными метриками
cv_r2 = cross_val_score(model, X, y, cv=kf, scoring='r2')
cv_neg_mse = cross_val_score(model, X, y, cv=kf, scoring='neg_mean_squared_error')
cv_rmse = np.sqrt(-cv_neg_mse)
# Вывод результатов
print(f"Средний R² по CV: {cv_r2.mean():.4f} ± {cv_r2.std():.4f}")
print(f"Средний RMSE по CV: {cv_rmse.mean():.4f} ± {cv_rmse.std():.4f}")
Улучшение модели через регуляризацию:
from sklearn.linear_model import Ridge, Lasso
from sklearn.model_selection import GridSearchCV
# Настройка параметров для Ridge-регрессии
ridge_params = {'alpha': [0\.01, 0.1, 1.0, 10.0, 100.0]}
ridge = Ridge()
ridge_gs = GridSearchCV(ridge, ridge_params, cv=5, scoring='neg_mean_squared_error')
ridge_gs.fit(X_train, y_train)
# Вывод наилучших параметров и результатов
print(f"Лучший параметр alpha для Ridge: {ridge_gs.best_params_['alpha']}")
print(f"RMSE с оптимальной Ridge-регрессией: {np.sqrt(-ridge_gs.best_score_):.4f}")
# Аналогично для Lasso-регрессии
lasso_params = {'alpha': [0\.0001, 0.001, 0.01, 0.1, 1.0]}
lasso = Lasso(max_iter=10000)
lasso_gs = GridSearchCV(lasso, lasso_params, cv=5, scoring='neg_mean_squared_error')
lasso_gs.fit(X_train, y_train)
print(f"Лучший параметр alpha для Lasso: {lasso_gs.best_params_['alpha']}")
print(f"RMSE с оптимальной Lasso-регрессией: {np.sqrt(-lasso_gs.best_score_):.4f}")
Полиномиальное расширение признаков для моделирования нелинейностей:
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
# Создание пайплайна для полиномиальной регрессии
poly_model = Pipeline([
('poly', PolynomialFeatures(degree=2, include_bias=False)),
('linear', LinearRegression())
])
# Обучение модели
poly_model.fit(X_train, y_train)
# Оценка на тестовой выборке
poly_pred = poly_model.predict(X_test)
poly_r2 = r2_score(y_test, poly_pred)
poly_rmse = np.sqrt(mean_squared_error(y_test, poly_pred))
print(f"R² полиномиальной модели: {poly_r2:.4f}")
print(f"RMSE полиномиальной модели: {poly_rmse:.4f}")
Выбор оптимального набора признаков:
from sklearn.feature_selection import SelectKBest, f_regression
from sklearn.pipeline import Pipeline
# Создание пайплайна с отбором признаков
feature_selection = Pipeline([
('selector', SelectKBest(f_regression, k=5)),
('model', LinearRegression())
])
# Поиск оптимального числа признаков
param_grid = {'selector__k': list(range(1, X_train.shape[1] + 1))}
grid = GridSearchCV(feature_selection, param_grid, cv=5, scoring='r2')
grid.fit(X_train, y_train)
# Вывод результатов
print(f"Оптимальное число признаков: {grid.best_params_['selector__k']}")
print(f"R² модели с отобранными признаками: {grid.best_score_:.4f}")
# Определение важности признаков
selector = SelectKBest(f_regression, k='all')
selector.fit(X, y)
feature_scores = pd.DataFrame({
'Признак': X.columns,
'F-значение': selector.scores_,
'p-значение': selector.pvalues_
})
feature_scores = feature_scores.sort_values('F-значение', ascending=False)
print(feature_scores)
Стратегии для улучшения модели линейной регрессии:
- Проверка и устранение мультиколлинеарности — используйте VIF (Variance Inflation Factor) или выполните PCA
- Трансформация данных — логарифмирование, извлечение корня или Box-Cox преобразование для нормализации распределений
- Обработка выбросов — идентификация и обработка влиятельных наблюдений с помощью метрик Cook's distance или DFFITS
- Создание взаимодействий признаков — добавление произведений переменных, если есть основания полагать, что они взаимодействуют
- Проверка нелинейности — включение полиномиальных или сплайновых преобразований признаков
Сравнительная таблица регуляризованных версий линейной регрессии:
| Параметр | Стандартная линейная регрессия | Ridge-регрессия | Lasso-регрессия |
|---|---|---|---|
| Регуляризация | Нет | L2-норма (сумма квадратов) | L1-норма (сумма модулей) |
| Отбор признаков | Не выполняет | Уменьшает веса | Обнуляет незначимые веса |
| Работа с мультиколлинеарностью | Плохая | Хорошая | Средняя |
| Интерпретируемость | Высокая | Средняя | Высокая (из-за отсева признаков) |
| Вычислительная сложность | Низкая | Низкая | Средняя |
Линейная регрессия — фундаментальный инструмент машинного обучения, который при правильном подходе демонстрирует впечатляющую эффективность. Осваивая её в Python, вы не просто изучаете алгоритм — вы приобретаете мощный аналитический навык, позволяющий извлекать ценные инсайты из данных. Помните: даже в эпоху сложных нейросетей именно понимание базовых принципов и умение интерпретировать результаты делают вас настоящим специалистом по данным, способным не только предсказывать, но и объяснять.
Читайте также
- Кросс-валидация в машинном обучении: защита от переобучения
- Компьютерное зрение Python: техники обработки изображений и детекции
- Анализ данных: как научиться работать с информацией и не утонуть
- Аналитика данных для бизнеса: как превратить цифры в прибыль
- Python для анализа данных: настройка инструментов и среды
- 7 мощных методов оценки ML-моделей в Scikit-learn: руководство
- Топ-10 источников датасетов для машинного обучения: полное руководство
- Kaggle: как покорить Эверест машинного обучения для новичков
- Рекомендательные системы: как они работают и почему без них никуда
- 5 проверенных методов создания случайных массивов в Python