Что такое бэггинг?

Бэггинг: Bootstrap Aggregating

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

Концепция

Бэггинг (Bootstrap Aggregating) — это техника, при которой:

1. Создаём несколько подвыборок данных (с возвращением)
2. Обучаем отдельный алгоритм на каждой подвыборке
3. Усредняем предсказания всех моделей

              Исходные данные
                    |
          __________|__________
         |         |          |
       Sample 1  Sample 2   Sample 3
         |         |          |
      Model 1   Model 2    Model 3
         |         |          |
       Pred 1   Pred 2    Pred 3
         |         |          |
          \______ Усреднить ______/
                    |
              Финальный результат

Как это работает

from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Создадим данные
X, y = make_classification(n_samples=1000, n_features=20, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# Единая модель (обычное дерево)
dt_single = DecisionTreeClassifier(random_state=42)
dt_single.fit(X_train, y_train)
y_pred_single = dt_single.predict(X_test)
accuracy_single = accuracy_score(y_test, y_pred_single)
print(f"Single tree accuracy: {accuracy_single:.4f}")

# Бэггинг: несколько деревьев
bag = BaggingClassifier(
    estimator=DecisionTreeClassifier(),
    n_estimators=10,  # количество моделей
    random_state=42
)
bag.fit(X_train, y_train)
y_pred_bag = bag.predict(X_test)
accuracy_bag = accuracy_score(y_test, y_pred_bag)
print(f"Bagging accuracy: {accuracy_bag:.4f}")

# Вывод: Bagging обычно лучше
# Single tree accuracy: 0.8750
# Bagging accuracy: 0.8950

Процесс выборки (Bootstrap)

import numpy as np
from sklearn.utils import resample

# Исходные данные
data = np.array([1, 2, 3, 4, 5])

# Bootstrap выборка (с возвращением)
for i in range(3):
    bootstrap_sample = resample(data, n_samples=len(data), replace=True)
    print(f"Sample {i+1}: {bootstrap_sample}")

# Вывод:
# Sample 1: [2 5 4 4 3]  ← некоторые элементы повторяются
# Sample 2: [1 3 5 3 1]
# Sample 3: [2 2 4 5 1]

Важно: выборка делается с возвращением (with replacement), поэтому одинаковые элементы могут быть выбраны несколько раз.

Типы усреднения

Классификация:

# Голосование по большинству (voting)
# Если 6 из 10 моделей говорят "класс 1", то финальный результат = "класс 1"

y_preds = np.array([
    [0, 1, 1, 1, 1, 0, 1, 1, 1, 0],  # модель 1: класс
    [0, 1, 1, 1, 1, 0, 1, 1, 0, 1],  # модель 2: класс
    [0, 1, 0, 1, 1, 1, 1, 1, 1, 0]   # модель 3: класс
])

final_pred = (y_preds.sum(axis=0) > 1.5).astype(int)  # большинство
print(final_pred)  # [0 1 0 1 1 0 1 1 0 0]

Регрессия:

# Арифметическое среднее
preds = np.array([
    [100, 200, 150],  # модель 1
    [105, 195, 155],  # модель 2
    [95, 205, 145]    # модель 3
])

final_pred = preds.mean(axis=0)
print(final_pred)  # [100. 200. 150.] усреднённые

Random Forest: специальный случай бэггинга

Random Forest — это бэггинг с декоррелированием деревьев.

from sklearn.ensemble import RandomForestClassifier

# Random Forest = BaggingClassifier + случайный выбор признаков
rf = RandomForestClassifier(
    n_estimators=100,
    max_features='sqrt',  # используем только sqrt(n_features) признаков
    random_state=42
)

Разница:

• Бэггинг: случайные выборки строк, все признаки
• Random Forest: случайные выборки строк + случайные выборки признаков

Это делает деревья более независимыми и разнообразными.

Пример: как бэггинг уменьшает дисперсию

# Задача: предсказать цену на основе 20 случайных признаков
from sklearn.ensemble import BaggingRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.datasets import make_regression
from sklearn.metrics import mean_squared_error

X, y = make_regression(n_samples=200, n_features=20, noise=10, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# Одно дерево (высокая дисперсия)
dt = DecisionTreeRegressor(max_depth=10, random_state=42)
dt.fit(X_train, y_train)
mse_dt = mean_squared_error(y_test, dt.predict(X_test))

# Бэггинг (низкая дисперсия)
bag = BaggingRegressor(
    estimator=DecisionTreeRegressor(max_depth=10),
    n_estimators=50,
    random_state=42
)
bag.fit(X_train, y_train)
mse_bag = mean_squared_error(y_test, bag.predict(X_test))

print(f"Decision Tree MSE: {mse_dt:.2f}")
print(f"Bagging MSE: {mse_bag:.2f}")

# Вывод: Bagging даёт меньшую ошибку
# Decision Tree MSE: 3500.45
# Bagging MSE: 2800.30  ← лучше!

Когда бэггинг работает хорошо

# 1. Нестабильные модели (high variance)
#    - Decision Trees (при глубине > 1)
#    - Neural Networks
#    - k-NN (при малых k)

# 2. Плохие модели
#    - Каждый слабый ученик предсказывает случайно
#    - Но много слабых учеников в согласии дают хороший результат

Когда бэггинг работает плохо

# 1. Стабильные модели (low variance)
#    - Linear Regression (уже имеет низкую дисперсию)
#    - Bias останется неизменным

# 2. Недостаточно данных
#    - Выборки слишком похожи
#    - Деревья не разнообразны

Out-of-Bag (OOB) Score

Уникальное преимущество бэггинга: бесплатная валидация.

from sklearn.ensemble import BaggingClassifier

bag = BaggingClassifier(
    estimator=DecisionTreeClassifier(),
    n_estimators=100,
    oob_score=True,  # вычислить OOB score
    random_state=42
)

bag.fit(X_train, y_train)
print(f"OOB Score: {bag.oob_score_:.4f}")

# OOB = оценка на примерах, которые НЕ вошли в конкретную выборку
# Это "бесплатная" valiadation set!

Практический пример: Real-world задача

from sklearn.datasets import load_iris
from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import cross_val_score

# Данные
iris = load_iris()
X, y = iris.data, iris.target

# Single tree
dt = DecisionTreeClassifier(random_state=42)
scores_dt = cross_val_score(dt, X, y, cv=5)

# Bagging
bag = BaggingClassifier(
    estimator=DecisionTreeClassifier(),
    n_estimators=50,
    random_state=42
)
scores_bag = cross_val_score(bag, X, y, cv=5)

print(f"Decision Tree CV score: {scores_dt.mean():.4f} +/- {scores_dt.std():.4f}")
print(f"Bagging CV score: {scores_bag.mean():.4f} +/- {scores_bag.std():.4f}")

# Вывод: Bagging обычно лучше
# Decision Tree CV score: 0.9467 +/- 0.0471
# Bagging CV score: 0.9600 +/- 0.0327

Вывод

• Бэггинг = Bootstrap + Aggregate (усреднить)
• Идея: много слабых моделей → одна сильная
• Уменьшает дисперсию, не влияет на bias
• Random Forest — лучший практический пример бэггинга
• OOB score — бесплатная валидация
• Работает лучше всего с нестабильными моделями (Decision Trees)