Что происходит со смещением и дисперсией при бустинге?

Question

claude-haiku-4.5 · Accepted Answer

## Смещение и дисперсия при бустинге

Бустинг (Boosting) — это один из самых эффективных методов ансамбля, который работает через принципиально иной механизм редукции смещения и дисперсии, чем баггинг. Понимание этого — ключ к эффективному использованию методов вроде Gradient Boosting и XGBoost.

### Базовые определения

**Смещение (Bias):**
- Ошибка из-за недостаточной сложности модели
- Модель недостаточно хорошо аппроксимирует истинную функцию
- Высокое смещение = underfitting

**Дисперсия (Variance):**
- Ошибка из-за чувствительности к конкретным данным обучения
- Модель хорошо подгоняется под шум в тренировочном наборе
- Высокая дисперсия = overfitting

```python
MSE = Bias² + Variance + Irreducible Error
```

### Фундаментальное различие: Баггинг vs Бустинг

**Баггинг (Bootstrap Aggregation):**
- Обучает независимые слабые ученики на случайных подвыборках
- **Уменьшает дисперсию** (усредняя независимые ошибки)
- Смещение остаётся примерно таким же

**Бустинг:**
- Обучает последовательные модели, корректируя ошибки предыдущих
- **Уменьшает смещение** (фокусируясь на трудных примерах)
- **Может увеличить дисперсию** (потребляет сложность)

### Что происходит с смещением при бустинге

**Смещение УМЕНЬШАЕТСЯ** значительно.

**Механизм:**
Бустинг работает путём последовательного добавления моделей, которые фокусируются на ошибках предыдущих. Это строит всё более сложную границу решения.

**Пример:**
```python
import numpy as np
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import GradientBoostingRegressor, AdaBoostRegressor

# Нелинейная функция (требует низкого смещения)
X = np.linspace(0, 10, 100).reshape(-1, 1)
y = np.sin(X).ravel() + 0.1 * np.random.randn(100)

# Одна неглубокая дерево (высокое смещение)
stump = DecisionTreeRegressor(max_depth=1)
stump.fit(X, y)
y_pred_stump = stump.predict(X)
bias_stump = np.mean((y - y_pred_stump)**2)  # High error
print(f"Bias of single stump: {bias_stump:.4f}")

# Бустинг (низкое смещение)
boost = GradientBoostingRegressor(n_estimators=100, max_depth=1)
boost.fit(X, y)
y_pred_boost = boost.predict(X)
bias_boost = np.mean((y - y_pred_boost)**2)  # Low error
print(f"Bias of boosting: {bias_boost:.4f}")

# Результат: bias_stump >> bias_boost
```

**Визуально:**
```
Ошибка от смещения со временем (число итераций бустинга):

┌─────────────────────────────────┐
│ Ошибка смещения                 │
│ │                               │
│ │ ╲                             │
│ │  ╲                            │
│ │   ╲___                        │
│ │       ╲____                   │
│ │            ╲_____             │
│ │                  ╲____        │
│ │                       ╲___    │
│ └──────────────────────────────│
│   0  20  40  60  80  100   Итерации
```

### Что происходит с дисперсией при бустинге

**Дисперсия МОЖЕТ УВЕЛИЧИТЬСЯ**, но обычно контролируется.

**Причины увеличения дисперсии:**

1. **Последовательная зависимость** — модели не независимы (в отличие от баггинга)
   ```python
   # Баггинг: модели обучаются независимо
   trees_bagging = []
   for i in range(100):
       X_sample, y_sample = bootstrap_sample(X, y)
       trees_bagging.append(DecisionTreeRegressor().fit(X_sample, y_sample))
   
   # Бустинг: каждая модель видит ошибки предыдущей
   trees_boosting = []
   residuals = y.copy()
   for i in range(100):
       tree = DecisionTreeRegressor(max_depth=3)
       tree.fit(X, residuals)  # Зависит от предыдущей!
       trees_boosting.append(tree)
       residuals -= learning_rate * tree.predict(X)
   ```

2. **Овер-фиттинг на шум** — при слишком большом количестве итераций
   ```python
   # Переобучение при n_estimators слишком высоком
   boost_overfit = GradientBoostingRegressor(n_estimators=1000)  # Опасно!
   boost_overfit.fit(X_train, y_train)
   
   # Контролируемое бустинг
   boost_controlled = GradientBoostingRegressor(
       n_estimators=100,
       max_depth=3,          # Ограничение сложности
       learning_rate=0.05,   # Медленное обучение
       subsample=0.8         # Регуляризация
   )
   ```

### Кривые обучения: Bias-Variance Trade-off

**Для одного слабого ученика (Stump):**
```
Ошибка
│
│  ╱╲
│ ╱  ╲         Training error (низкая дисперсия)
│╱    ╲___     
│       ╲      
│        ╲     Validation error (высокое смещение)
│         ╲___
└────────────────── Сложность модели
```
Высокое смещение, низкая дисперсия

**После 100 итераций бустинга:**
```
Ошибка
│      ╱╲
│     ╱  ╲     Training error (высокая дисперсия)
│    ╱    ╲
│   ╱      ╲___  
│  ╱          ╲  Validation error (низкое смещение)
│ ╱             ╲__
└──────────────────── Итерации бустинга
```
Низкое смещение, средняя-высокая дисперсия

### Практический пример: Gradient Boosting

```python
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import learning_curve
from sklearn.datasets import make_classification

X, y = make_classification(n_samples=1000, n_features=20, n_informative=10, 
                           random_state=42)

# Слабый ученик (high bias, low variance)
weak_learner = DecisionTreeClassifier(max_depth=1)
train_sizes, train_scores, val_scores = learning_curve(
    weak_learner, X, y, cv=5, train_sizes=np.linspace(0.1, 1, 10)
)

print("Слабый ученик (max_depth=1):")
print(f"  Train accuracy: {train_scores.mean():.3f}")
print(f"  Val accuracy: {val_scores.mean():.3f}")
print(f"  Bias: High, Variance: Low")

# Бустинг (low bias, medium-high variance)
boost = GradientBoostingClassifier(
    n_estimators=100,
    max_depth=3,
    learning_rate=0.1,
    random_state=42
)
train_sizes, train_scores, val_scores = learning_curve(
    boost, X, y, cv=5, train_sizes=np.linspace(0.1, 1, 10)
)

print("
Gradient Boosting (100 iterations):")
print(f"  Train accuracy: {train_scores.mean():.3f}")
print(f"  Val accuracy: {val_scores.mean():.3f}")
print(f"  Bias: Low, Variance: Medium")
```

### Как контролировать дисперсию в бустинге

**1. Learning Rate (Shrinkage)**
```python
boost = GradientBoostingClassifier(
    learning_rate=0.01,  # Меньше → ниже дисперсия, нужно больше итераций
    n_estimators=500     # Компенсируем меньший learning rate
)
# Эффект: каждое дерево вносит меньше вклада, снижая дисперсию
```

**2. Depth of trees**
```python
boost = GradientBoostingClassifier(
    max_depth=3,  # Меньше → проще модели, ниже дисперсия
)
# Эффект: каждое дерево менее сложное, меньше переобучение
```

**3. Subsample (Stochastic Boosting)**
```python
boost = GradientBoostingClassifier(
    subsample=0.7,  # Используем 70% данных на каждой итерации
)
# Эффект: добавляет шум, уменьшает дисперсию (как в баггинге)
```

**4. Регуляризация L1/L2**
```python
# XGBoost with L2 regularization
model = xgb.XGBClassifier(
    lambda=1.0,        # L2 regularization strength
    alpha=0.0,         # L1 regularization strength
    gamma=0            # Minimum loss reduction for split
)
```

### Сравнение: Bias-Variance для разных методов

| Метод | Bias | Variance | Когда использовать |
|-------|------|----------|-------------------|
| **Одно дерево (глубокое)** | Низкое | Высокая | Редко - переобучение |
| **Пень (shallow)** | Высокое | Низкая | Базовая линия |
| **Баггинг (Random Forest)** | Высокое | Низкая | Wenn Bias < Variance |
| **Бустинг (Gradient)** | Низкое | Средняя | Когда нужна точность |
| **Бустинг (XGBoost)** | Низкое | Низкая | Production - best |
| **Blending** | Низкое | Низкая | Ансамбли разных типов |

### Итог: Bias-Variance в бустинге

```
С бустингом:
✓ Смещение ↓ (ЗНАЧИТЕЛЬНОЕ снижение)
✓ Дисперсия ↑ (небольшой рост, но контролируемый)
✓ Общая ошибка ↓ (сильное снижение за счёт меньшего смещения)

Стратегия:
1. Начни с простых деревьев (high bias, low variance)
2. Добавляй итерации бустинга (уменьшаешь смещение)
3. Контролируй дисперсию через learning_rate, max_depth, subsample
4. Используй валидацию для нахождения оптимального баланса
```

**Практический совет:** В production я обычно использую:
- **learning_rate=0.05** (медленное обучение, низкая дисперсия)
- **max_depth=5-7** (баланс между смещением и дисперсией)
- **n_estimators=100-500** (до валидации)
- **subsample=0.8** (добавляет регуляризацию)

Эта конфигурация обычно даёт лучший баланс Bias-Variance в реальных задачах.

Метод	Bias	Variance	Когда использовать
Одно дерево (глубокое)	Низкое	Высокая	Редко - переобучение
Пень (shallow)	Высокое	Низкая	Базовая линия
Баггинг (Random Forest)	Высокое	Низкая	Wenn Bias < Variance
Бустинг (Gradient)	Низкое	Средняя	Когда нужна точность
Бустинг (XGBoost)	Низкое	Низкая	Production - best
Blending	Низкое	Низкая	Ансамбли разных типов

Что происходит со смещением и дисперсией при бустинге?

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

Смещение и дисперсия при бустинге

Базовые определения

Фундаментальное различие: Баггинг vs Бустинг

Что происходит с смещением при бустинге

Что происходит с дисперсией при бустинге

Кривые обучения: Bias-Variance Trade-off

Практический пример: Gradient Boosting

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

Сравнение: Bias-Variance для разных методов

Итог: Bias-Variance в бустинге