Какие ограничения есть у логистической регрессии?

Какие ограничения есть у логистической регрессии?

Введение

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

1. Линейная разделимость данных

Логистическая регрессия предполагает линейную разделимость классов в пространстве признаков.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification, make_moons

# Линейно разделимые данные
X_linear, y_linear = make_classification(
    n_samples=100, n_features=2, n_informative=2,
    n_redundant=0, random_state=42
)

# Нелинейно разделимые данные
X_moons, y_moons = make_moons(n_samples=100, noise=0.1, random_state=42)

# На линейно разделимых данных работает хорошо
lr = LogisticRegression()
lr.fit(X_linear, y_linear)
print(f"Точность на линейных данных: {lr.score(X_linear, y_linear):.4f}")

# На нелинейных данных работает плохо
lr.fit(X_moons, y_moons)
print(f"Точность на нелинейных данных: {lr.score(X_moons, y_moons):.4f}")

Решение: использовать полиномиальные признаки или более сложные модели (SVM, Random Forest, Neural Networks).

2. Чувствительность к масштабированию признаков

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

from sklearn.preprocessing import StandardScaler

# БЕЗ масштабирования
lr_raw = LogisticRegression(random_state=42, max_iter=1000)
lr_raw.fit(X_train, y_train)
print(f"Без масштабирования: {lr_raw.score(X_test, y_test):.4f}")

# С масштабированием
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

lr_scaled = LogisticRegression(random_state=42, max_iter=1000)
lr_scaled.fit(X_train_scaled, y_train)
print(f"С масштабированием: {lr_scaled.score(X_test_scaled, y_test):.4f}")

3. Проблема с дисбалансом классов

Если один класс намного реже другого, логистическая регрессия будет смещена в сторону большинства.

from sklearn.datasets import make_classification
from sklearn.metrics import precision_recall_curve, f1_score

# Сильный дисбаланс (95% vs 5%)
X, y = make_classification(
    n_samples=1000, weights=[0.95, 0.05],
    random_state=42
)

lr = LogisticRegression(random_state=42)
lr.fit(X, y)
predictions = lr.predict(X)

# Модель просто предсказывает класс 0
print(f"Класс 0 предсказано: {(predictions == 0).sum()}")
print(f"Класс 1 предсказано: {(predictions == 1).sum()}")

# Решение 1: class_weight
lr_balanced = LogisticRegression(class_weight='balanced', random_state=42)
lr_balanced.fit(X, y)
predictions_balanced = lr_balanced.predict(X)
print(f"\nС class_weight='balanced':")
print(f"Класс 1 предсказано: {(predictions_balanced == 1).sum()}")

# Решение 2: изменить threshold
from sklearn.metrics import confusion_matrix
proba = lr.predict_proba(X)
y_pred_threshold = (proba[:, 1] > 0.3).astype(int)  # Вместо 0.5
print(f"\nС threshold=0.3: {(y_pred_threshold == 1).sum()}")

4. Чувствительность к мультиколлинеарности

Если признаки сильно коррелированы, это может привести к нестабильным коэффициентам.

import pandas as pd
from sklearn.linear_model import LogisticRegression

# Создаем коррелированные признаки
np.random.seed(42)
X = np.random.randn(100, 3)
X[:, 1] = X[:, 0] + np.random.randn(100) * 0.01  # Очень коррелирован с X[:, 0]
y = (X[:, 0] + X[:, 2] > 0).astype(int)

lr = LogisticRegression(random_state=42)
lr.fit(X, y)

print(f"Коэффициенты: {lr.coef_[0]}")
print(f"Большие и нестабильные коэффициенты для коррелированных признаков")

# Решение: использовать регуляризацию L2 (Ridge)
lr_l2 = LogisticRegression(penalty='l2', C=1.0, random_state=42)
lr_l2.fit(X, y)
print(f"Коэффициенты с L2: {lr_l2.coef_[0]}")

5. Не подходит для многоклассовой классификации (много классов)

Для множества классов логистическая регрессия требует подхода "один против всех" (OvR) или "один против одного" (OvO), что усложняет интерпретацию.

from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification

# 5 классов
X, y = make_classification(
    n_samples=200, n_features=5, n_informative=5,
    n_redundant=0, n_classes=5, random_state=42
)

# OvR (по умолчанию для sklearn)
lr_ovr = LogisticRegression(multi_class='ovr', random_state=42, max_iter=1000)
lr_ovr.fit(X, y)
print(f"OvR: {lr_ovr.score(X, y):.4f}")

# multinomial (softmax)
lr_multinomial = LogisticRegression(multi_class='multinomial', random_state=42, max_iter=1000)
lr_multinomial.fit(X, y)
print(f"Multinomial: {lr_multinomial.score(X, y):.4f}")

6. Ограниченная выразительность на сложных данных

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

# Нужны взаимодействия
X_interactions = np.column_stack([
    X[:, 0],
    X[:, 1],
    X[:, 0] * X[:, 1],  # Взаимодействие
    X[:, 0] ** 2,       # Нелинейность
])

lr_with_interactions = LogisticRegression(random_state=42)
lr_with_interactions.fit(X_interactions, y)
print(f"С взаимодействиями: {lr_with_interactions.score(X_interactions, y):.4f}")

7. Требует достаточного объема данных

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

# Правило: n_samples >= 10 * n_features минимум
n_features = 100
n_samples_small = 50   # Слишком мало
n_samples_good = 1000  # Достаточно

X_small = np.random.randn(n_samples_small, n_features)
y_small = (np.random.randn(n_samples_small) > 0).astype(int)

X_good = np.random.randn(n_samples_good, n_features)
y_good = (np.random.randn(n_samples_good) > 0).astype(int)

lr = LogisticRegression(random_state=42)
lr.fit(X_small, y_small)
print(f"На малой выборке: {lr.score(X_small, y_small):.4f}")  # Может быть переобучение

lr.fit(X_good, y_good)
print(f"На хорошей выборке: {lr.score(X_good, y_good):.4f}")  # Более стабильно

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

Если вероятность очень близка к 0 или 1, градиент может стать очень маленьким, что замедляет обучение.

9. Интерпретируемость разных шкал

Коэффициенты интерпретируются как логарифм шансов (log-odds), что не всегда интуитивно.

# Коэффициент = 0.5
# Это означает: при увеличении признака на 1
# логарифм шансов увеличивается на 0.5
# Шансы увеличиваются в e^0.5 = 1.65 раз

coeff = 0.5
odds_ratio = np.exp(coeff)
print(f"Увеличение признака на 1 увеличивает шансы в {odds_ratio:.2f} раз")

Сводка ограничений

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