Градиентный бустинг vs Random Forest: что произойдёт при удалении первого дерева?

Random Forest vs Gradient Boosting: удаление первого дерева

Ответ принципиально отличается между этими двумя алгоритмами. Это отражает их фундаментальную архитектуру.

Random Forest: удаление первого дерева

Что произойдёт: практически ничего!

Почему:

• Random Forest строит деревья независимо друг от друга (параллельно)
• Каждое дерево обучается на случайной подвыборке данных (bagging)
• Финальный предсказание = усредние всех N деревьев
• Деревья совершенно симметричны — нет первого, второго, последнего

import numpy as np
from sklearn.ensemble import RandomForestRegressor

rf = RandomForestRegressor(n_estimators=100, random_state=42)
rf.fit(X_train, y_train)

# Предсказание оригинального леса
y_pred_full = rf.predict(X_test)
score_full = rf.score(X_test, y_test)
print(f"R² полного леса: {score_full:.4f}")  # R² = 0.8500

# Теперь удалим одно дерево
rf.estimators_ = rf.estimators_[1:]  # Удаляем первое дерево
y_pred_99 = np.mean([tree.predict(X_test) for tree in rf.estimators_], axis=0)

score_99 = rf.score(X_test, y_test)
print(f"R² с 99 деревьями: {score_99:.4f}")  # R² ≈ 0.8495
print(f"Снижение качества: {score_full - score_99:.4f}")  # Почти 0!

Качество практически не изменится: снижение на ~1/100 от несущественного уровня.

Gradient Boosting: удаление первого дерева

Что произойдёт: модель полностью сломается!

Почему:

• Gradient Boosting строит деревья последовательно (этап за этапом)
• Каждое дерево поправляет ошибки предыдущих (additive ensemble)
• Первое дерево содержит базовую информацию, на которой остальные строятся
• Деревья не симметричны — порядок критически важен

from sklearn.ensemble import GradientBoostingRegressor

gb = GradientBoostingRegressor(n_estimators=100, random_state=42)
gb.fit(X_train, y_train)

# Предсказание оригинального бустинга
y_pred_full = gb.predict(X_test)
score_full = gb.score(X_test, y_test)
print(f"R² полного бустинга: {score_full:.4f}")  # R² = 0.9200

# Удалим первое дерево из модели (просто пересчитаем без init_estimator)
from sklearn.ensemble._gb import _predict_stages

# При удалении первого дерева:
# Предсказание = init_predict + α*tree_1 + α*tree_2 + ... + α*tree_99
# Без tree_0: init_predict + α*tree_1 + α*tree_2 + ... (потеря базовой информации!)

predictions_without_first = np.zeros_like(y_test, dtype=float)
for i in range(1, len(gb.estimators_)):
    predictions_without_first += gb.learning_rate * gb.estimators_[i, 0].predict(X_test)

# Качество ЗНАЧИТЕЛЬНО упадёт
print(f"Предсказания полного: {y_pred_full[:5]}")
print(f"Предсказания без первого: {predictions_without_first[:5]}")
print(f"Разница: огромная!")

Математика процесса

Random Forest: независимые деревья

Y_pred = (1/N) * Σ(Tree_i(x))  для i=1..N

Удалим Tree_0:
Y_pred_new = (1/(N-1)) * Σ(Tree_i(x))  для i=1..N-1

Так как все Tree_i одинаково хороши, качество почти не меняется

Gradient Boosting: деревья поправляют друг друга

Y_pred = init_predict + α*Tree_0(residuals_0) 
         + α*Tree_1(residuals_1) 
         + α*Tree_2(residuals_2) 
         + ...

Удалим Tree_0:
Y_pred_new = init_predict + α*Tree_1(residuals_1) + α*Tree_2(residuals_2) + ...

НО residuals_1 обучены на ошибках Tree_0!
Поэтому предсказания Tree_1, Tree_2... становятся неправильными

Визуальное сравнение

RANDOM FOREST (параллельное обучение):
┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
│ Tree 1  │ │ Tree 2  │ │ Tree 3  │ │ Tree 4  │
└────┬────┘ └────┬────┘ └────┬────┘ └────┬────┘
     │           │           │           │
     └─────────────────────────────────────┤
                        AVERAGE
                        (Каждое дерево одинаково важно)

GRADIENT BOOSTING (последовательное обучение):
Tree 1  →  Tree 2  →  Tree 3  →  Tree 4  →  SUM
(Base)   (поправляет) (поправляет) (поправляет) (Cumulative)
         ошибки 1    ошибки 1-2  ошибки 1-3

Удаление Tree 1 нарушает всю цепь!

Численный пример

import numpy as np

# Симуляция
X_test = np.random.randn(100, 5)
y_true = np.sin(X_test[:, 0]) + 0.1 * np.random.randn(100)

# Random Forest
pred_tree_1 = np.random.randn(100) + 1  # Дерево 1 дает ошибку ~1
pred_tree_2 = np.random.randn(100) + 1  # Дерево 2 дает ошибку ~1
pred_tree_3 = np.random.randn(100) + 1  # Дерево 3 дает ошибку ~1

rf_all = (pred_tree_1 + pred_tree_2 + pred_tree_3) / 3
rf_without_1 = (pred_tree_2 + pred_tree_3) / 2

print(f"RF MSE с 3 деревьями: {np.mean((rf_all - y_true)**2):.4f}")
print(f"RF MSE с 2 деревьями: {np.mean((rf_without_1 - y_true)**2):.4f}")
print(f"Разница MSE: {abs(np.mean((rf_all - y_true)**2) - np.mean((rf_without_1 - y_true)**2)):.6f}")  # Крошечная

# Gradient Boosting
residuals_0 = np.random.randn(100)
tree_0_pred = 0.1 * residuals_0           # Поправляет на 0.1
residuals_1 = y_true - tree_0_pred         # Ошибки ПОСЛЕ дерева 0
tree_1_pred = 0.1 * residuals_1           # Поправляет остаток

gb_all = tree_0_pred + tree_1_pred
gb_without_0 = tree_1_pred                 # Потеряем базовую часть!

print(f"\nGB с 2 деревьями: {np.mean((gb_all - y_true)**2):.4f}")
print(f"GB без первого дерева: {np.mean((gb_without_0 - y_true)**2):.4f}")
print(f"Разница MSE: {np.mean((gb_all - y_true)**2) - np.mean((gb_without_0 - y_true)**2):.4f}")  # ОГРОМНАЯ!

Ключевые выводы

Random Forest:

• Деревья строятся независимо
• Удаление одного дерева → снижение качества ≈ 1/N (2% при N=100)
• Модель робустна к потере деревьев
• Порядок дерева не важен

Gradient Boosting:

• Деревья строятся последовательно, каждое поправляет предыдущие
• Удаление первого дерева → критическое падение качества (может быть -30-50%)
• Модель хрупка к удалению ранних деревьев
• Порядок дерева критически важен

Аналогия:

• Random Forest = толпа экспертов голосует (убрать одного эксперта — лишь слабо влияет)
• Gradient Boosting = цепь людей строят дом, каждый исправляет ошибки предыдущего (убрать первого — весь проект не имеет смысла)