Что такое бинарная классификация?

Question

claude-haiku-4.5 · Accepted Answer

## Бинарная классификация: предсказание двух классов

**Бинарная классификация** — это задача машинного обучения, где нужно предсказать один из двух возможных результатов (классов).

Просто говоря: ДА или НЕТ, 1 или 0, положительное или отрицательное.

### Примеры бинарной классификации

```
1. Прогноз оттока клиента (Churn):
   Вход: история покупок, взаимодействия
   Выход: Отойдёт ли клиент? (Да/Нет)

2. Одобрение кредита:
   Вход: доход, кредитная история, возраст
   Выход: Одобрить ли кредит? (Да/Нет)

3. Обнаружение fraud (мошенничество):
   Вход: сумма, место, время, паттерны
   Выход: Мошенничество? (Да/Нет)

4. Предсказание конверсии:
   Вход: характеристики пользователя
   Выход: Совершит ли покупку? (Да/Нет)

5. Спам фильтр:
   Вход: текст письма, отправитель
   Выход: Спам? (Да/Нет)
```

### Базовый пример

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, confusion_matrix

# Данные: предсказываю отток клиента
df = pd.DataFrame({
    'age': [25, 35, 45, 28, 50, 32],
    'tenure_months': [12, 24, 60, 6, 36, 18],
    'monthly_charges': [50, 75, 100, 40, 120, 60],
    'churn': [0, 0, 0, 1, 1, 0]  # 0=остался, 1=ушёл
})

# Разделяю на train и test
X = df[['age', 'tenure_months', 'monthly_charges']]
y = df['churn']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

# Обучаю логистическую регрессию
model = LogisticRegression()
model.fit(X_train, y_train)

# Предсказываю
y_pred = model.predict(X_test)

print(f"Предсказания: {y_pred}")
print(f"Вероятности оттока: {model.predict_proba(X_test)[:, 1]}")
```

### Основные алгоритмы

**1. Логистическая регрессия (самый простой)**

```python
from sklearn.linear_model import LogisticRegression

# Работает вероятностно
model = LogisticRegression()
model.fit(X_train, y_train)

# Предсказывает класс
predictions = model.predict(X_test)  # [0, 1, 0, 1, ...]

# Предсказывает вероятность
probabilities = model.predict_proba(X_test)  # [[0.8, 0.2], [0.3, 0.7], ...]
#                                              (P(class=0), P(class=1))
```

**Плюсы:**
- Быстро обучается
- Интерпретируемо (коэффициенты показывают влияние)
- Дает вероятности

**Минусы:**
- Предполагает линейность
- Может не работать если данные сложные

**2. Random Forest (более сложный)**

```python
from sklearn.ensemble import RandomForestClassifier

model = RandomForestClassifier(n_estimators=100)
model.fit(X_train, y_train)

predictions = model.predict(X_test)
probabilities = model.predict_proba(X_test)
```

**Плюсы:**
- Работает с нелинейными зависимостями
- Автоматически находит важные признаки
- Часто лучше точность

**3. Gradient Boosting (ещё лучше)**

```python
from sklearn.ensemble import GradientBoostingClassifier

model = GradientBoostingClassifier()
model.fit(X_train, y_train)
```

**4. SVM (Support Vector Machine)**

```python
from sklearn.svm import SVC

model = SVC(probability=True)  # probability=True чтобы получать вероятности
model.fit(X_train, y_train)
```

### Матрица ошибок (Confusion Matrix)

```python
from sklearn.metrics import confusion_matrix

y_pred = model.predict(X_test)
cm = confusion_matrix(y_test, y_pred)

print(cm)

# Результат:
#        Predicted
#        Neg  Pos
# Actual[[ 45   5 ]  ← TN=45, FP=5  (Negative)
#        [ 8   22]  ← FN=8, TP=22  (Positive)
```

**Терминология:**
- **TP (True Positive)** — правильно предсказал 1 (22)
- **FP (False Positive)** — ошибка, предсказал 1, а было 0 (5)
- **FN (False Negative)** — ошибка, предсказал 0, а было 1 (8)
- **TN (True Negative)** — правильно предсказал 0 (45)

### Метрики оценки

**1. Accuracy (точность) — доля правильных предсказаний**

```python
accuracy = (TP + TN) / (TP + FP + FN + TN)
accuracy = (22 + 45) / (22 + 5 + 8 + 45) = 67 / 80 = 83.75%

# Код
from sklearn.metrics import accuracy_score
accuracy = accuracy_score(y_test, y_pred)
```

**Проблема:** Если датасет несбалансирован (1% положительных), accuracy может быть высокой но бесполезной.

**2. Precision (точность класса 1) — из всех предсказанных 1, сколько верных?**

```python
precision = TP / (TP + FP) = 22 / (22 + 5) = 81.5%

# Интерпретация: из 27 предсказанных отток, 22 действительно ушли

from sklearn.metrics import precision_score
precision = precision_score(y_test, y_pred)
```

**Когда важна:** Когда ложный alarm дорогой (например, отправлять письмо удерживающее клиента)

**3. Recall (полнота) — из всех реальных 1, сколько предсказал?**

```python
recall = TP / (TP + FN) = 22 / (22 + 8) = 73.3%

# Интерпретация: из 30 реальных оттоков, нашли 22

from sklearn.metrics import recall_score
recall = recall_score(y_test, y_pred)
```

**Когда важна:** Когда пропустить положительный класс дорого (например, не найти мошенничество)

**4. F1-Score (баланс между precision и recall)**

```python
f1 = 2 * (precision * recall) / (precision + recall)
f1 = 2 * (0.815 * 0.733) / (0.815 + 0.733) = 0.771

from sklearn.metrics import f1_score
f1 = f1_score(y_test, y_pred)
```

**Когда использовать:** Когда нужен баланс между precision и recall

**5. AUC-ROC (Area Under the Curve - Receiver Operating Characteristic)**

```python
from sklearn.metrics import roc_auc_score, roc_curve
import matplotlib.pyplot as plt

# AUC показывает способность модели отделять классы
auc = roc_auc_score(y_test, y_pred_proba)
print(f"AUC: {auc:.3f}")  # 1.0 = идеально, 0.5 = random

# ROC кривая
fpr, tpr, thresholds = roc_curve(y_test, y_pred_proba)
plt.plot(fpr, tpr, label=f'AUC = {auc:.3f}')
plt.plot([0, 1], [0, 1], 'r--', label='Random')
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.legend()
plt.show()
```

### Практический пример: Предсказание оттока клиента

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, roc_auc_score
from sklearn.preprocessing import StandardScaler

# Загружаю данные
df = pd.read_csv('churn_data.csv')

# Подготовка (очень важно!)
df = df.drop(['customer_id', 'name'], axis=1)  # Не нужны для модели
df['gender'] = df['gender'].map({'M': 1, 'F': 0})  # Кодирую категории

# Разделяю на признаки и целевую
X = df.drop('churn', axis=1)
y = df['churn']

# Масштабирую (опционально, но помогает)
scaler = StandardScaler()
X = scaler.fit_transform(X)

# Разделяю на train/test
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Обучаю
model = RandomForestClassifier(n_estimators=100)
model.fit(X_train, y_train)

# Оцениваю
y_pred = model.predict(X_test)
y_pred_proba = model.predict_proba(X_test)[:, 1]

print(classification_report(y_test, y_pred))
print(f"AUC: {roc_auc_score(y_test, y_pred_proba):.3f}")

# Важность признаков
feature_importance = pd.DataFrame({
    'feature': X.columns,
    'importance': model.feature_importances_
}).sort_values('importance', ascending=False)

print("
Топ 10 важных признаков:")
print(feature_importance.head(10))
```

### Выбор threshold (порог классификации)

```python
# По умолчанию threshold = 0.5
# Если вероятность > 0.5 → предсказываю 1
# Если вероятность <= 0.5 → предсказываю 0

# Но можно изменить для оптимизации

from sklearn.metrics import precision_recall_curve

# Найти оптимальный threshold
precisions, recalls, thresholds = precision_recall_curve(y_test, y_pred_proba)

# Выбрать threshold где F1 максимален
f1_scores = 2 * (precisions[:-1] * recalls[:-1]) / (precisions[:-1] + recalls[:-1])
optimal_idx = f1_scores.argmax()
optimal_threshold = thresholds[optimal_idx]

print(f"Оптимальный threshold: {optimal_threshold:.3f}")

# Применить новый threshold
y_pred_new = (y_pred_proba >= optimal_threshold).astype(int)
```

### Несбалансированные данные

**Проблема:** Если 99% класс 0 и 1% класс 1

```python
# Решение 1: class_weight
model = LogisticRegression(class_weight='balanced')

# Решение 2: oversampling (копирую меньший класс)
from imblearn.over_sampling import SMOTE

smote = SMOTE()
X_resampled, y_resampled = smote.fit_resample(X_train, y_train)
model.fit(X_resampled, y_resampled)

# Решение 3: undersampling (удаляю из большего класса)
from imblearn.under_sampling import RandomUnderSampler
```

### Вывод

**Бинарная классификация — предсказание одного из двух классов.**

**Основные концепции:**
- Confusion Matrix — матрица ошибок
- Precision — точность положительного класса
- Recall — полнота положительного класса
- F1 — баланс между precision и recall
- AUC-ROC — способность отделять классы

**Практический цикл:**
1. Подготовка данных
2. Выбор модели (логистическая регрессия, Random Forest, XGBoost)
3. Обучение
4. Оценка на test set
5. Оптимизация threshold
6. Deployment

**Помни:** Accuracy может быть обманчива, используй precision, recall, F1 и AUC для оценки.

Что такое бинарная классификация?

Комментарии (1)

Бинарная классификация: предсказание двух классов

Примеры бинарной классификации

Базовый пример

Основные алгоритмы

Матрица ошибок (Confusion Matrix)

Метрики оценки

Практический пример: Предсказание оттока клиента

Выбор threshold (порог классификации)

Несбалансированные данные

Вывод