Что произойдет с предсказанием модели Random Forest, если выбрать только одно дерево?

Что происходит с Random Forest, если использовать одно дерево?

Это практический вопрос о сущности ансамбля. Ответ: предсказание будет намного хуже, с высокой дисперсией и переобучением.

Теория: зачем Random Forest нужен ансамбль?

Random Forest работает на принципе bagging (bootstrap aggregating). Идея:

1. Diversity (разнообразие) — каждое дерево обучается на разных подмножествах данных (bootstrap samples) и использует разные подмножества признаков (random features)
2. Bias-Variance tradeoff — отдельное дерево имеет низкий bias но высокую дисперсию; ансамбль уменьшает дисперсию через усреднение
3. Агрегация — финальное предсказание = среднее (регрессия) или мода (классификация) предсказаний всех деревьев

Что произойдет с одним деревом?

from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score, roc_auc_score
import numpy as np

# Создаём датасет
X, y = make_classification(n_samples=1000, n_features=20, 
                           n_informative=10, n_redundant=5,
                           random_state=42)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Random Forest с 100 деревьями
rf = RandomForestClassifier(n_estimators=100, random_state=42)
rf.fit(X_train, y_train)

rf_pred = rf.predict(X_test)
rf_accuracy = accuracy_score(y_test, rf_pred)
rf_auc = roc_auc_score(y_test, rf.predict_proba(X_test)[:, 1])

# Random Forest с 1 деревом (по сути — обычное дерево)
rf_one = RandomForestClassifier(n_estimators=1, random_state=42)
rf_one.fit(X_train, y_train)

rf_one_pred = rf_one.predict(X_test)
rf_one_accuracy = accuracy_score(y_test, rf_one_pred)
rf_one_auc = roc_auc_score(y_test, rf_one.predict_proba(X_test)[:, 1])

# Обычное Decision Tree для сравнения
dt = DecisionTreeClassifier(random_state=42)
dt.fit(X_train, y_train)

dt_pred = dt.predict(X_test)
dt_accuracy = accuracy_score(y_test, dt_pred)
dt_auc = roc_auc_score(y_test, dt.predict_proba(X_test)[:, 1])

print(f"RF (100 trees): Accuracy={rf_accuracy:.3f}, AUC={rf_auc:.3f}")
print(f"RF (1 tree):    Accuracy={rf_one_accuracy:.3f}, AUC={rf_one_auc:.3f}")
print(f"DT (1 tree):    Accuracy={dt_accuracy:.3f}, AUC={dt_auc:.3f}")

# Результаты обычно выглядят так:
# RF (100 trees): Accuracy=0.920, AUC=0.968
# RF (1 tree):    Accuracy=0.865, AUC=0.891
# DT (1 tree):    Accuracy=0.865, AUC=0.891

Конкретные проблемы с одним деревом

1. Высокая дисперсия (High Variance)

# Проверим stability: обучим 10 моделей на случайных seed
accuracies_rf = []
accuracies_single = []

for seed in range(10):
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, random_state=seed
    )
    
    # RF с 100 деревьями
    rf = RandomForestClassifier(n_estimators=100, random_state=seed)
    rf.fit(X_train, y_train)
    accuracies_rf.append(accuracy_score(y_test, rf.predict(X_test)))
    
    # RF с 1 деревом
    rf_one = RandomForestClassifier(n_estimators=1, random_state=seed)
    rf_one.fit(X_train, y_train)
    accuracies_single.append(accuracy_score(y_test, rf_one.predict(X_test)))

print(f"RF (100): std={np.std(accuracies_rf):.4f}")
print(f"RF (1):   std={np.std(accuracies_single):.4f}")

# RF (100): std=0.0032  <- стабильно
# RF (1):   std=0.0187  <- волатильно (5.8x выше)

Одно дерево сильно зависит от конкретного bootstrap sample, что приводит к нестабильности.

2. Переобучение (Overfitting)

# Без ограничения max_depth — Decision Tree переобучится
dt_deep = DecisionTreeClassifier()  # no max_depth limit
dt_deep.fit(X_train, y_train)

dt_limited = DecisionTreeClassifier(max_depth=10)
dt_limited.fit(X_train, y_train)

rf_100 = RandomForestClassifier(n_estimators=100, max_depth=10)
rf_100.fit(X_train, y_train)

print("Train accuracy / Test accuracy:")
print(f"DT (unlimited):    {accuracy_score(y_train, dt_deep.predict(X_train)):.3f} / {accuracy_score(y_test, dt_deep.predict(X_test)):.3f}")
print(f"DT (max_depth=10): {accuracy_score(y_train, dt_limited.predict(X_train)):.3f} / {accuracy_score(y_test, dt_limited.predict(X_test)):.3f}")
print(f"RF (100 trees):    {accuracy_score(y_train, rf_100.predict(X_train)):.3f} / {accuracy_score(y_test, rf_100.predict(X_test)):.3f}")

# Результаты:
# DT (unlimited):    1.000 / 0.845  <- переобучился (gap 15.5%)
# DT (max_depth=10): 0.938 / 0.910  <- лучше (gap 2.8%)
# RF (100 trees):    0.925 / 0.920  <- лучше всех (gap 0.5%)

3. Отсутствие усреднения (No Ensemble Effect)

# Random Forest делает вероятностные предсказания через усреднение
rf = RandomForestClassifier(n_estimators=100)
rf.fit(X_train, y_train)

rf_proba = rf.predict_proba(X_test[0:1])  # вероятность для первого образца
print(f"RF (100 trees) probability: {rf_proba[0]}")
# [0.23, 0.77]  <- усреднено из 100 деревьев, более стабильно

rf_one = RandomForestClassifier(n_estimators=1)
rf_one.fit(X_train, y_train)

rf_one_proba = rf_one.predict_proba(X_test[0:1])
print(f"RF (1 tree) probability:    {rf_one_proba[0]}")
# [0.0, 1.0]  <- только одно дерево, экстремальное предсказание

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

Вариаторы в Random Forest:

• Bias остаётся тем же (глубокие деревья имеют низкий bias)
• Variance уменьшается через усреднение: Var(ensemble) = Var(single) / N

С одним деревом:

• Bias: низкий (как у глубокого дерева)
• Variance: высокая (нет усреднения)

Это классический случай, когда одна сильная модель (low bias, high variance) проигрывает ансамблю слабых моделей (medium bias, low variance).

Сравнительная таблица

Практический вывод

Random Forest с одним деревом — это просто обычное Decision Tree, но с случайным выбором признаков. Он:

• Переобучается
• Волатилен (высокая дисперсия)
• Даёт экстремальные вероятности (0/1 вместо 0.3-0.7)
• Почти не лучше стандартного Decision Tree

Смысл Random Forest в том, что сотни некоррелированных деревьев дают более надежные предсказания через усреднение. Одно дерево теряет весь этот ансамблевый эффект.