Регрессионные модели в Python

Логистическая регрессия

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

Основные принципы логистической регрессии

• Модель: логистическая регрессия использует логистическую функцию (или функцию сигмоида), чтобы преобразовать линейную комбинацию признаков в вероятности, которые лежат в диапазоне от 0 до 1. Это позволяет модели предсказывать вероятность принадлежности к определенному классу.
• Функция сигмоида: она вычисляет вероятность принадлежности к классу.
• Обучение: модель обучается на основе данных с метками, используя метод максимального правдоподобия для оценки коэффициентов модели, чтобы максимально точно предсказывать метки классов.

Ниже приведен пример использования логистической регрессии с библиотекой scikit-learn для решения задачи бинарной классификации:

---

# Импорт необходимых библиотек

import numpy as np

from sklearn.linear_model import LogisticRegression

from sklearn.datasets import load_iris

from sklearn.model_selection import train_test_split

from sklearn.metrics import accuracy_score, confusion_matrix

import matplotlib.pyplot as plt

import seaborn as sns

 

# Загрузка данных

data = load_iris()

X = data.data

y = data.target

 

# Преобразование задачи в бинарную классификацию (только два класса)

y = (y != 0).astype(int)  # Преобразуем данные так, чтобы 0 был одним классом, а остальные — другим

 

# Разделение данных на обучающую и тестовую выборки

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

 

# Создание и обучение модели

model = LogisticRegression()

model.fit(X_train, y_train)

 

# Прогнозирование на тестовой выборке

y_pred = model.predict(X_test)

 

# Оценка точности модели

accuracy = accuracy_score(y_test, y_pred)

conf_matrix = confusion_matrix(y_test, y_pred)

 

print(f’Accuracy: {accuracy:.2f}’)

print(‘Confusion Matrix:’)

print(conf_matrix)

 

# Визуализация матрицы ошибок

plt.figure(figsize=(8, 6))

sns.heatmap(conf_matrix, annot=True, fmt=’d’, cmap=’Blues’,

xticklabels=[‘Class 0’, ‘Class 1’],

yticklabels=[‘Class 0’, ‘Class 1’])

plt.xlabel(‘Predicted’)

plt.ylabel(‘Actual’)

plt.title(‘Confusion Matrix’)

plt.show()

---

В этом примере мы используем набор данных Iris из sklearn. Мы преобразуем задачу в бинарную классификацию, чтобы упростить пример. Разделяем данные на обучающую и тестовую выборки, создаем объект LogisticRegression и обучаем его на обучающих данных. Далее делаем прогнозы на тестовой выборке, затем вычисляем точность модели и выводим матрицу ошибок. Затем визуализируем матрицу ошибок с помощью seaborn, чтобы лучше понять, как модель справляется с задачей классификации.

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

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

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

Основные принципы полиномиальной регрессии

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

Приведем пример полиномиальной регрессии с использованием библиотеки scikit-learn для моделирования данных с нелинейной зависимостью.

---

# Импорт необходимых библиотек

import numpy as np

import matplotlib.pyplot as plt

from sklearn.preprocessing import PolynomialFeatures

from sklearn.linear_model import LinearRegression

from sklearn.pipeline import make_pipeline

 

# Генерация примера данных

np.random.seed(0)

X = np.sort(5 * np.random.rand(100, 1), axis=0)

y = np.sin(X).ravel() + np.random.normal(0, 0.1, X.shape[0])

 

# Создание полиномиальных признаков (порядка 3)

poly = PolynomialFeatures(degree=3)

X_poly = poly.fit_transform(X)

 

# Создание и обучение модели

model = LinearRegression()

model.fit(X_poly, y)

 

# Прогнозирование

X_fit = np.linspace(0, 5, 100).reshape(-1, 1)

X_fit_poly = poly.transform(X_fit)

y_pred = model.predict(X_fit_poly)

 

# Визуализация результатов

plt.scatter(X, y, color=’blue’, label=’Исходные данные’)

plt.plot(X_fit, y_pred, color=’red’, label=’Полиномиальная регрессия (3-й порядок)’)

plt.xlabel(‘Независимая переменная’)

plt.ylabel(‘Зависимая переменная’)

plt.title(‘Полиномиальная регрессия’)

plt.legend()

plt.show()

---

Здесь мы создаем набор данных с нелинейной зависимостью между переменными, добавляя шум для более реалистичного вида. С помощью PolynomialFeatures создаем полиномиальные признаки (в данном случае до третьего порядка), потом создаем объект LinearRegression и обучаем его на полиномиальных признаках. Прогнозируем значения на новых данных и визуализируем результаты вместе с исходными данными, чтобы увидеть, как полиномиальная регрессия адаптируется к данным.

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

Квантильная регрессия

Квантильная регрессия в Python – это метод статистического анализа, который позволяет моделировать не только среднее значение зависимой переменной, как в линейной регрессии, но и другие квантили (quantiles) распределения этой переменной. Это делает квантильную регрессию полезной для изучения различных аспектов распределения данных и оценки влияния независимых переменных на разные точки распределения зависимой переменной.

Основные принципы квантильной регрессии

• Модель: в квантильной регрессии модель строится для заданного квантиля (например, медиана, 25-й или 75-й процентиль). Квантили представляют собой точки, которые делят распределение на определенные части. Модель помогает оценить, как независимые переменные влияют на выбранный квантиль зависимой переменной.
• Функция потерь: в отличие от обычной линейной регрессии, которая использует среднеквадратичную ошибку, квантильная регрессия использует функцию потерь, основанную на абсолютной ошибке, взвешенной квантилем. Это позволяет моделировать различные части распределения данных.
• Гибкость: квантильная регрессия предоставляет более гибкий подход к анализу данных, особенно когда распределение зависимой переменной не симметрично или имеет выбросы.

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

---

# Импорт необходимых библиотек

import numpy as np

import pandas as pd

import statsmodels.api as sm

import matplotlib.pyplot as plt

 

# Генерация примера данных

np.random.seed(0)

X = np.linspace(0, 10, 100)

y = 2 + 3 * X + np.random.normal(0, 2, size=X.shape[0]) + np.random.choice([0, 10], size=X.shape[0], p=[0.9, 0.1])

X = sm.add_constant(X)  # Добавляем константу для линейной модели

 

# Квантильная регрессия для 0.25, 0.5 и 0.75 квантилей

quantiles = [0.25, 0.5, 0.75]

models = {}

results = {}

 

for q in quantiles:

model = sm.QuantReg(y, X)

result = model.fit(q=q)

models[q] = result

results[q] = result.predict(X)

 

# Визуализация результатов

plt.scatter(X[:, 1], y, color=’blue’, label=’Исходные данные’)

plt.plot(X[:, 1], results[0.25], color=’green’, label=’0.25 квантиль’)

plt.plot(X[:, 1], results[0.5], color=’red’, label=’0.50 квантиль (медиана)’)

plt.plot(X[:, 1], results[0.75], color=’purple’, label=’0.75 квантиль’)

plt.xlabel(‘Независимая переменная’)

plt.ylabel(‘Зависимая переменная’)

plt.title(‘Квантильная регрессия’)

plt.legend()

plt.show()

---

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

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

Лассо-регрессия и ридж-регрессия

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

Лассо-регрессия (lasso regression)

Лассо-регрессия (Least Absolute Shrinkage and Selection Operator) добавляет к функции потерь линейной регрессии штраф, пропорциональный абсолютной величине коэффициентов. Это приводит к тому, что некоторые коэффициенты могут стать нулевыми, что позволяет осуществлять отбор признаков.

Например:

---

# Импорт необходимых библиотек

import numpy as np

from sklearn.linear_model import Lasso

from sklearn.datasets import load_diabetes

from sklearn.model_selection import train_test_split

from sklearn.metrics import mean_squared_error

import matplotlib.pyplot as plt

 

# Загрузка данных

data = load_diabetes()

X = data.data

y = data.target

 

# Разделение данных на обучающую и тестовую выборки

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

 

# Создание и обучение модели Лассо-регрессии

alpha = 0.1  # Параметр регуляризации

lasso = Lasso(alpha=alpha)

lasso.fit(X_train, y_train)

 

# Прогнозирование на тестовой выборке

y_pred = lasso.predict(X_test)

 

# Оценка модели

mse = mean_squared_error(y_test, y_pred)

print(f’Mean Squared Error (Lasso): {mse:.2f}’)

print(f’Коэффициенты Лассо-регрессии: {lasso.coef_}’)

 

# Визуализация коэффициентов

plt.figure(figsize=(10, 6))

plt.bar(range(len(lasso.coef_)), lasso.coef_)

plt.xlabel(‘Признаки’)

plt.ylabel(‘Коэффициенты’)

plt.title(‘Коэффициенты Лассо-регрессии’)

plt.show()

---

Ридж-регрессия (ridge regression)

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

---

# Импорт необходимых библиотек

import numpy as np

from sklearn.linear_model import Ridge

from sklearn.datasets import load_diabetes

from sklearn.model_selection import train_test_split

from sklearn.metrics import mean_squared_error

import matplotlib.pyplot as plt

 

# Загрузка данных

data = load_diabetes()

X = data.data

y = data.target

 

# Разделение данных на обучающую и тестовую выборки

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

 

# Создание и обучение модели Ридж-регрессии

alpha = 0.1  # Параметр регуляризации

ridge = Ridge(alpha=alpha)

ridge.fit(X_train, y_train)

 

# Прогнозирование на тестовой выборке

y_pred = ridge.predict(X_test)

 

# Оценка модели

mse = mean_squared_error(y_test, y_pred)

print(f’Mean Squared Error (Ridge): {mse:.2f}’)

print(f’Коэффициенты Ридж-регрессии: {ridge.coef_}’)

 

# Визуализация коэффициентов

plt.figure(figsize=(10, 6))

plt.bar(range(len(ridge.coef_)), ridge.coef_)

plt.xlabel(‘Признаки’)

plt.ylabel(‘Коэффициенты’)

plt.title(‘Коэффициенты Ридж-регрессии’)

plt.show()

---

Основные различия между лассо и ридж-регрессией

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

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

Метод главных компонент

Метод главных компонент (Principal Component Analysis, PCA) – это техника уменьшения размерности данных, которая используется для преобразования набора взаимозависимых переменных в меньший набор независимых переменных, называемых главными компонентами. PCA помогает уменьшить размерность данных, сохраняя при этом как можно больше информации о вариации данных. Это особенно полезно в задачах, где данные имеют много признаков, что может привести к проблемам с производительностью и интерпретацией.

Цель PCA – найти новые оси (главные компоненты), вдоль которых данные имеют наибольшую дисперсию. Эти оси называются главными компонентами. Первая главная компонента объясняет наибольшую часть вариации данных, вторая – наибольшую часть оставшейся вариации, и так далее. PCA может использоваться для уменьшения размерности, визуализации данных, удаления шумов и улучшения производительности алгоритмов машинного обучения.

Приведем пример использования PCA для уменьшения размерности данных и визуализации на двумерном графике:

---

# Импорт необходимых библиотек

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

from sklearn.decomposition import PCA

from sklearn.datasets import load_iris

 

# Загрузка данных

data = load_iris()

X = data.data

y = data.target

 

# Создание объекта PCA и преобразование данных

pca = PCA(n_components=2)  # Сокращаем до двух компонент

X_pca = pca.fit_transform(X)

 

# Создание DataFrame для удобства визуализации

df = pd.DataFrame(X_pca, columns=[‘Principal Component 1’, ‘Principal Component 2’])

df[‘Target’] = y

 

# Визуализация данных

plt.figure(figsize=(8, 6))

scatter = plt.scatter(df[‘Principal Component 1’], df[‘Principal Component 2’], c=df[‘Target’], cmap=’viridis’, alpha=0.7)

plt.xlabel(‘Principal Component 1’)

plt.ylabel(‘Principal Component 2’)

plt.title(‘PCA на данных Iris’)

plt.colorbar(scatter, label=’Target’)

plt.show()

 

# Печать объясненной дисперсии

print(f’Explained variance ratio: {pca.explained_variance_ratio_}’)

---

Регрессия наименьших частичных квадратов

Регрессия наименьших частичных квадратов (Partial Least Squares Regression, PLS) – это метод регрессии, который применяется для моделирования зависимостей между признаками и целевой переменной, особенно когда количество признаков велико и они могут быть сильно коррелированы. PLS объединяет аспекты регрессии и методов понижения размерности, таких как PCA, чтобы улучшить предсказательную способность модели.

Для применения PLS-регрессии в Python можно использовать библиотеку scikit-learn. Приведем пример:

---

# Импорт необходимых библиотек

import numpy as np

import matplotlib.pyplot as plt

from sklearn.cross_decomposition import PLSRegression

from sklearn.datasets import load_diabetes

from sklearn.model_selection import train_test_split

from sklearn.metrics import mean_squared_error

 

# Загрузка данных

data = load_diabetes()

X = data.data

y = data.target

 

# Разделение данных на обучающую и тестовую выборки

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

 

# Создание и обучение модели PLS-регрессии

n_components = 2  # Количество компонентов (скрытых переменных)

pls = PLSRegression(n_components=n_components)

pls.fit(X_train, y_train)

 

# Прогнозирование на тестовой выборке

y_pred = pls.predict(X_test)

 

# Оценка модели

mse = mean_squared_error(y_test, y_pred)

print(f’Mean Squared Error (PLS): {mse:.2f}’)

 

# Визуализация первых двух компонент (для понимания структуры)

X_train_transformed = pls.transform(X_train)

plt.figure(figsize=(10, 6))

plt.scatter(X_train_transformed[:, 0], X_train_transformed[:, 1], c=y_train, cmap=’viridis’, edgecolor=’k’)

plt.xlabel(‘PLS Component 1’)

plt.ylabel(‘PLS Component 2’)

plt.title(‘PLS Components of Training Data’)

plt.colorbar(label=’Target’)

plt.show()

---

 

Порядковая регрессия

Порядковая регрессия (Ordinal Regression) – это статистический метод, используемый для моделирования зависимостей между порядковой зависимой переменной и независимыми переменными. Порядковая зависимая переменная принимает дискретные, упорядоченные значения, которые представляют собой различные уровни или категории с определенным порядком, но без конкретных числовых значений.

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

---

# Импорт необходимых библиотек

import numpy as np

import pandas as pd

import statsmodels.api as sm

import statsmodels.formula.api as smf

import matplotlib.pyplot as plt

 

# Создание искусственного набора данных

np.random.seed(0)

n = 200

X1 = np.random.normal(size=n)

X2 = np.random.normal(size=n)

y = (X1 + X2 > 0).astype(int)  # Дискретный исходной переменной (0 или 1)

 

# Создание DataFrame с порядковой зависимой переменной

df = pd.DataFrame({

‘X1’: X1,

‘X2’: X2,

‘y’: y

})

 

# Преобразование целевой переменной в порядковую

df[‘y’] = pd.Categorical(df[‘y’], categories=[0, 1], ordered=True)

 

# Создание модели порядковой регрессии

model = smf.mnlogit(‘y ~ X1 + X2’, data=df)

result = model.fit()

 

# Вывод результатов

print(result.summary())

 

# Прогнозирование и визуализация

df[‘predicted_prob’] = result.predict(df[[‘X1’, ‘X2’]])

plt.scatter(df[‘X1’], df[‘predicted_prob’][:, 1], c=df[‘y’].cat.codes, cmap=’coolwarm’)

plt.xlabel(‘X1’)

plt.ylabel(‘Предсказанная вероятность’)

plt.title(‘Вероятность принадлежности к категории 1′)

plt.colorbar(label=’Категория’)

plt.show()

---

Регрессия Пуассона и отрицательная биноминальная регрессия

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

Регрессия Пуассона (Poisson Regression)

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

---

# Импорт необходимых библиотек

import numpy as np

import pandas as pd

import statsmodels.api as sm

from sklearn.datasets import load_boston

from sklearn.preprocessing import StandardScaler

 

# Загрузка данных (используем набор данных о ценах на жилье в Бостоне для примера)

data = load_boston()

X = pd.DataFrame(data.data, columns=data.feature_names)

y = np.random.poisson(lam=3, size=X.shape[0])  # Генерация счетных данных

 

# Стандартизация данных

scaler = StandardScaler()

X_scaled = scaler.fit_transform(X)

 

# Создание и обучение модели Пуассона

X_scaled = sm.add_constant(X_scaled)  # Добавление константы

model = sm.GLM(y, X_scaled, family=sm.families.Poisson())

result = model.fit()

 

# Вывод результатов

print(result.summary())

---

Отрицательная биномиальная регрессия (Negative Binomial Regression)

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

---

# Импорт необходимых библиотек

import numpy as np

import pandas as pd

import statsmodels.api as sm

from sklearn.datasets import load_boston

from sklearn.preprocessing import StandardScaler

 

# Загрузка данных (используем набор данных о ценах на жилье в Бостоне для примера)

data = load_boston()

X = pd.DataFrame(data.data, columns=data.feature_names)

y = np.random.negative_binomial(n=10, p=0.5, size=X.shape[0])  # Генерация счетных данных

 

# Стандартизация данных

scaler = StandardScaler()

X_scaled = scaler.fit_transform(X)

 

# Создание и обучение модели отрицательной биномиальной регрессии

X_scaled = sm.add_constant(X_scaled)  # Добавление константы

model = sm.GLM(y, X_scaled, family=sm.families.NegativeBinomial())

result = model.fit()

 

# Вывод результатов

print(result.summary())

---

Регрессия Кокса

Регрессия Кокса (Cox Proportional Hazards Model) – это метод статистического анализа, используемый для изучения и моделирования времени до наступления события. Это особенно полезно в медицинских исследованиях и других областях, где нужно оценить влияние различных факторов на время до события, такого как смерть, рецидив болезни или другое событие выживания. Регрессия Кокса используется для оценки риска и анализа выживаемости.

Для применения модели Кокса можно использовать библиотеку lifelines, которая предоставляет инструменты для анализа выживаемости и регрессии Кокса.

Пример на данных о пациентах

---

# Импорт необходимых библиотек

import pandas as pd

import numpy as np

from lifelines import CoxPHFitter

from lifelines.datasets import load_rossi

 

# Загрузка данных (набор данных Rossi о рецидиве преступлений)

data = load_rossi()

print(data.head())

 

# Создание объекта модели Кокса

cph = CoxPHFitter()

 

# Обучение модели

cph.fit(data, duration_col=’week’, event_col=’arrest’)

 

# Вывод результатов модели

cph.print_summary()

 

# Предсказание и оценка

cph.plot()

---

Заключение

Регрессионные модели в Python представляют собой мощный инструмент для анализа данных и прогнозирования. Используя такие библиотеки, как NumPy, Pandas, SciPy, Scikit-Learn и StatsModels, можно эффективно решать широкий спектр задач регрессии, начиная от простых линейных моделей до сложных нелинейных и полиномиальных регрессий. Эти инструменты не только упрощают процесс моделирования, но и предоставляют мощные средства для оценки качества модели и визуализации результатов.

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