Как превратить линейную регрессию в классификатор?

Как превратить линейную регрессию в классификатор

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

1. ПРОСТОЕ ПОРОГОВОЕ ПРАВИЛО (Threshold)

Самый простой способ — добавить пороговую функцию к предсказаниям линейной регрессии:

from sklearn.linear_model import LinearRegression
import numpy as np
import matplotlib.pyplot as plt

# Линейная регрессия
model_lr = LinearRegression()
model_lr.fit(X_train, y_train_continuous)

# Получить непрерывные предсказания
y_pred_continuous = model_lr.predict(X_test)

# Применить пороговое правило
threshold = 0.5
y_pred_classified = (y_pred_continuous >= threshold).astype(int)

print(f"Linear regression prediction: {y_pred_continuous[0]:.3f}")
print(f"Classified (threshold={threshold}): {y_pred_classified[0]}")

# Это простой способ, но не оптимальный
accuracy = np.mean(y_pred_classified == y_test)
print(f"Accuracy: {accuracy:.3f}")

2. ЛОГИСТИЧЕСКАЯ РЕГРЕССИЯ (вероятностный подход)

Логистическая регрессия — это естественное расширение линейной регрессии для классификации. Она добавляет сигмоид-функцию:

from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, roc_auc_score

# Линейная комбинация (как в линейной регрессии)
# z = β₀ + β₁x₁ + β₂x₂ + ... + βₙxₙ

# Применить сигмоид (логистическую функцию)
# p(y=1) = 1 / (1 + e^(-z))

# Это встроено в LogisticRegression
model_logistic = LogisticRegression()
model_logistic.fit(X_train, y_train_binary)

# Получить вероятности
y_pred_proba = model_logistic.predict_proba(X_test)[:, 1]  # P(y=1)

# Получить классы (по умолчанию threshold=0.5)
y_pred_class = model_logistic.predict(X_test)

print(f"Probability P(y=1): {y_pred_proba[0]:.3f}")
print(f"Predicted class: {y_pred_class[0]}")

# Оценка
accuracy = accuracy_score(y_test, y_pred_class)
auc_score = roc_auc_score(y_test, y_pred_proba)
print(f"Accuracy: {accuracy:.3f}")
print(f"ROC-AUC: {auc_score:.3f}")

3. МАТЕМАТИКА: ОТ LINEAR К LOGISTIC

# Линейная регрессия предсказывает непрерывное значение
# y_pred = β₀ + β₁x₁ + ... (может быть < 0 или > 1)

# Логистическая регрессия преобразует это в вероятность:
# p(y=1 | x) = σ(β₀ + β₁x₁ + ...) где σ — сигмоид

import numpy as np

def sigmoid(z):
    """
    Сигмоид функция: σ(z) = 1 / (1 + e^(-z))
    Преобразует любое число в вероятность [0, 1]
    """
    return 1 / (1 + np.exp(-z))

# Примеры
z_values = np.array([-5, -2, 0, 2, 5])
probs = sigmoid(z_values)

print("z -> P(y=1):")
for z, p in zip(z_values, probs):
    print(f"  z={z:2}: P={p:.4f}")

# Визуализация
z = np.linspace(-6, 6, 100)
y = sigmoid(z)

plt.figure(figsize=(10, 6))
plt.plot(z, y, 'b-', linewidth=2, label='σ(z) = 1/(1+e^(-z))')
plt.axhline(y=0.5, color='r', linestyle='--', label='Decision boundary (0.5)')
plt.axvline(x=0, color='g', linestyle='--', label='z=0')
plt.xlabel('z (linear combination)')
plt.ylabel('P(y=1)')
plt.title('Sigmoid Function: From Linear to Logistic')
plt.legend()
plt.grid()
plt.show()

4. СРАВНЕНИЕ: LINEAR vs LOGISTIC

from sklearn.linear_model import LinearRegression, LogisticRegression
import numpy as np

# Примерные данные
X = np.array([[1], [2], [3], [4], [5], [6], [7], [8]])
y = np.array([0, 0, 0, 1, 1, 1, 1, 1])

# Линейная регрессия
model_linear = LinearRegression()
model_linear.fit(X, y)
pred_linear = model_linear.predict(X)

# Логистическая регрессия
model_logistic = LogisticRegression()
model_logistic.fit(X, y)
pred_logistic = model_logistic.predict_proba(X)[:, 1]

# Визуализация
plt.figure(figsize=(12, 6))

plt.scatter(X, y, s=100, alpha=0.6, label='Data')
plt.plot(X, pred_linear, 'r-', linewidth=2, label='Linear Regression')
plt.plot(X, pred_logistic, 'b-', linewidth=2, label='Logistic Regression')
plt.axhline(y=0.5, color='g', linestyle='--', alpha=0.5, label='Decision boundary')

plt.xlabel('X')
plt.ylabel('y (Linear) or P(y=1) (Logistic)')
plt.title('Linear vs Logistic Regression')
plt.legend()
plt.grid()
plt.show()

print("\nРазница:")
print(f"Linear Regression: может предсказывать < 0 или > 1")
print(f"  Min: {pred_linear.min():.3f}, Max: {pred_linear.max():.3f}")
print(f"\nLogistic Regression: всегда в [0, 1]")
print(f"  Min: {pred_logistic.min():.3f}, Max: {pred_logistic.max():.3f}")

5. МНОГОКЛАССОВАЯ КЛАССИФИКАЦИЯ

Softmax регрессия — расширение логистической на K > 2 классов:

from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris

# Для многоклассовой классификации
X, y = load_iris(return_X_y=True)

model = LogisticRegression(multi_class='multinomial', max_iter=200)
model.fit(X, y)

# Вероятности для каждого класса
y_proba = model.predict_proba(X[:5])
print(f"Probabilities for first 5 samples (3 classes):")
print(y_proba)

# Класс с наибольшей вероятностью
y_pred = model.predict(X[:5])
print(f"\nPredicted classes: {y_pred}")

# Математика softmax:
# P(y=k | x) = e^(z_k) / Σ(e^(z_j)) для j=1...K
# где z_k = β₀ᵏ + β₁ᵏx₁ + ... (своя линейная комбинация на класс)

6. ВЫВОД ВЕРОЯТНОСТЕЙ ЧЕРЕЗ LINEAR REGRESSION

Можно эмулировать логистическую регрессию:

from sklearn.linear_model import LinearRegression
import numpy as np

# 1. Обучить линейную регрессию
model = LinearRegression()
model.fit(X_train, y_train_binary)

# 2. Получить предсказания
z = model.predict(X_test)

# 3. Применить сигмоид для преобразования в вероятности
def sigmoid(z):
    return 1 / (1 + np.exp(-np.clip(z, -500, 500)))  # clip для избежания overflow

y_proba_from_linear = sigmoid(z)

# 4. Применить пороговое правило
y_pred = (y_proba_from_linear >= 0.5).astype(int)

print(f"P(y=1) from linear regression + sigmoid: {y_proba_from_linear[0]:.3f}")
print(f"Predicted class: {y_pred[0]}")

# Сравнить с логистической регрессией
from sklearn.linear_model import LogisticRegression
model_logistic = LogisticRegression()
model_logistic.fit(X_train, y_train_binary)
y_proba_logistic = model_logistic.predict_proba(X_test)[:, 1]

print(f"\nP(y=1) from logistic regression: {y_proba_logistic[0]:.3f}")
print(f"Difference: {abs(y_proba_from_linear[0] - y_proba_logistic[0]):.4f}")

7. РЕГУЛЯРИЗАЦИЯ И OPTIMIZATION

from sklearn.linear_model import LogisticRegression

# Логистическая регрессия поддерживает регуляризацию

# L2 регуляризация (Ridge)
model_l2 = LogisticRegression(penalty='l2', C=1.0, solver='lbfgs')

# L1 регуляризация (Lasso) для feature selection
model_l1 = LogisticRegression(penalty='l1', C=1.0, solver='liblinear')

# Elastic Net (L1 + L2)
model_elastic = LogisticRegression(penalty='elasticnet', C=1.0, solver='saga', l1_ratio=0.5)

model_l2.fit(X_train, y_train)
model_l1.fit(X_train, y_train)

print(f"L2 non-zero coefficients: {np.sum(model_l2.coef_ != 0)}")
print(f"L1 non-zero coefficients: {np.sum(model_l1.coef_ != 0)}")
print(f"\nL1 спарсивнее, идеально для feature selection")

8. ПРАКТИЧЕСКИЙ ПРИМЕР: ПОЛНЫЙ PIPELINE

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score

# Pipeline: линейный классификатор
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('logistic', LogisticRegression(max_iter=1000))
])

# Обучение
pipeline.fit(X_train, y_train)

# Предсказание
y_pred_proba = pipeline.predict_proba(X_test)[:, 1]
y_pred = pipeline.predict(X_test)

# Оценка
from sklearn.metrics import roc_auc_score, accuracy_score
auc = roc_auc_score(y_test, y_pred_proba)
acc = accuracy_score(y_test, y_pred)

print(f"ROC-AUC: {auc:.3f}")
print(f"Accuracy: {acc:.3f}")

# Cross-validation
scores = cross_val_score(pipeline, X_train, y_train, cv=5, scoring='roc_auc')
print(f"CV ROC-AUC: {scores.mean():.3f} (+/- {scores.std():.3f})")

Итоги

Способы превратить линейную регрессию в классификатор:

1. Пороговое правило (y > 0.5): простой, но не оптимальный
2. Логистическая регрессия (добавить сигмоид): оптимальный для бинарной классификации
3. Softmax регрессия: для многоклассовой классификации
4. Linear Regression + Sigmoid: эмуляция логистической регрессии
5. С регуляризацией: L1/L2 для контроля переобучения

Математически:

• Linear: y = β₀ + β₁x (может быть любое число)
• Logistic: P(y=1) = σ(β₀ + β₁x) = 1/(1+e^(-(β₀ + β₁x))) ∈ [0,1]
• Softmax: P(y=k) = e^(z_k) / Σe^(z_j) (вероятности K классов)

Практика:

• Для бинарной классификации: используй LogisticRegression
• Для многоклассовой: используй LogisticRegression с multi_class='multinomial'
• Всегда нормализуй признаки (StandardScaler) перед логистической регрессией