Градієнтний бустинг та XGBoost — послідовне виправлення помилок

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor

# Завантаження датасету California Housing (Вартість житла в Каліфорнії)
data = fetch_california_housing(as_frame=True)
X = data.data
y = data.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Ансамбль Random Forest (Випадковий ліс) зі 100 дерев
rf = RandomForestRegressor(n_estimators=100, random_state=42, n_jobs=-1)
rf.fit(X_train, y_train)
y_pred_rf = rf.predict(X_test)

# Аналіз систематичного зміщення (Bias) за ціновими сегментами (ціни в $100k)
bins = [0.0, 1.5, 3.0, 4.5, np.inf]
bin_labels = ['$0–150k', '$150–300k', '$300–450k', '$450k+']
segment_names = [
    'Бюджетне житло',
    'Базовий сегмент',
    'Дорогий сегмент',
    'Елітна нерухомість'
]

errors_by_bin = []
for i in range(len(bins) - 1):
    mask = (y_test >= bins[i]) & (y_test < bins[i+1])
    diff = y_pred_rf[mask] - y_test[mask]
    mean_err = diff.mean()
    errors_by_bin.append(mean_err)

print("📊 Аналіз систематичного зміщення (Bias) Random Forest:")
for label, seg, err in zip(bin_labels, segment_names, errors_by_bin):
    direction = "переоцінює (завищує)" if err > 0 else "недооцінює (занижує)"
    print(f"  {label} ({seg}): {direction} на ${abs(err)*100000:,.0f}")

import numpy as np

# Дані: площа та ціна трьох квартир
area = np.array([50, 80, 120])
price = np.array([40000, 65000, 95000], dtype=float)

# Симуляція 5 ітерацій Gradient Boosting (Градієнтний бустинг)
learning_rate = 0.1
predictions = np.full(len(price), price.mean())  # F_0 = mean ($66,667)

print("Ітерація 0 (Baseline / Базове середнє):")
print(f"  Передбачення (Predictions): {np.round(predictions).astype(int)}")
print(f"  Залишки (Residuals):        {np.round(price - predictions).astype(int)}\n")

for iteration in range(1, 6):
    residuals = price - predictions
    
    # Симулюємо слабке дерево (Weak learner): наближає залишки з точністю 95%
    tree_pred = residuals * 0.95
    
    # Оновлення ансамблю: F_m = F_{m-1} + eta * h_m
    predictions += learning_rate * tree_pred
    
    mae = np.abs(price - predictions).mean()
    print(f"Ітерація {iteration}:")
    print(f"  Передбачення (Predictions): {np.round(predictions).astype(int)}")
    print(f"  Залишки (Residuals):        {np.round(price - predictions).astype(int)}")
    print(f"  MAE (Середня абсолютна помилка): {mae:.0f}\n")

import time
import numpy as np
import pandas as pd
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.ensemble import GradientBoostingRegressor, RandomForestRegressor
from sklearn.metrics import r2_score, mean_absolute_error, mean_squared_error

# Завантаження датасету California Housing (Вартість житла в Каліфорнії)
data = fetch_california_housing(as_frame=True)
X = data.data
y = data.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Навчання Gradient Boosting (Градієнтний бустинг зі sklearn)
start = time.time()
gb = GradientBoostingRegressor(
    n_estimators=100,
    learning_rate=0.1,
    max_depth=3,
    random_state=42
)
gb.fit(X_train, y_train)
gb_time = time.time() - start

y_pred_gb = gb.predict(X_test)
r2_gb_train = gb.score(X_train, y_train)
r2_gb_test = r2_score(y_test, y_pred_gb)
mae_gb_test = mean_absolute_error(y_test, y_pred_gb)
rmse_gb_test = np.sqrt(mean_squared_error(y_test, y_pred_gb))

print("🌳 Gradient Boosting (Градієнтний бустинг зі sklearn):")
print(f"  R² train (Навчальна вибірка): {r2_gb_train:.4f}")
print(f"  R² test (Тестова вибірка):    {r2_gb_test:.4f}")
print(f"  MAE test (Середня абсолютна помилка):  {mae_gb_test:.4f}")
print(f"  RMSE test (Корінь із середньоквадратичної): {rmse_gb_test:.4f}")
print(f"  Час навчання: {gb_time:.2f}s")

# Порівняємо з Random Forest (Випадковий ліс, 100 дерев)
start = time.time()
rf = RandomForestRegressor(n_estimators=100, random_state=42, n_jobs=-1)
rf.fit(X_train, y_train)
rf_time = time.time() - start

y_pred_rf = rf.predict(X_test)
r2_rf_train = rf.score(X_train, y_train)
r2_rf_test = r2_score(y_test, y_pred_rf)
mae_rf_test = mean_absolute_error(y_test, y_pred_rf)
rmse_rf_test = np.sqrt(mean_squared_error(y_test, y_pred_rf))

print("\n🌲 Random Forest (Випадковий ліс для порівняння):")
print(f"  R² train (Навчальна вибірка): {r2_rf_train:.4f}")
print(f"  R² test (Тестова вибірка):    {r2_rf_test:.4f}")
print(f"  MAE test (Середня абсолютна помилка):  {mae_rf_test:.4f}")
print(f"  RMSE test (Корінь із середньоквадратичної): {rmse_rf_test:.4f}")
print(f"  Час навчання: {rf_time:.2f}s")

print("\n📊 Порівняння базових моделей:")
print(f"  Різниця R² (RF vs GB): {(r2_rf_test - r2_gb_test) * 100:+.2f}%")
print(f"  GB повільніший за паралельний RF у: {gb_time / rf_time:.1f}× разів")

import time
from xgboost import XGBRegressor
from sklearn.metrics import r2_score, mean_absolute_error, mean_squared_error

# Навчання XGBoost (eXtreme Gradient Boosting)
start = time.time()
xgb = XGBRegressor(
    n_estimators=100,
    learning_rate=0.1,
    max_depth=5,
    subsample=0.8,           # випадкова підвибірка 80% рядків (Subsample)
    colsample_bytree=0.8,    # випадкова підвибірка 80% колонок (Colsample by tree)
    random_state=42,
    n_jobs=-1
)
xgb.fit(X_train, y_train)
xgb_time = time.time() - start

y_pred_xgb = xgb.predict(X_test)
r2_xgb_train = xgb.score(X_train, y_train)
r2_xgb_test = r2_score(y_test, y_pred_xgb)
mae_xgb_test = mean_absolute_error(y_test, y_pred_xgb)
rmse_xgb_test = np.sqrt(mean_squared_error(y_test, y_pred_xgb))

print("🚀 XGBoost (eXtreme Gradient Boosting):")
print(f"  R² train (Навчальна вибірка): {r2_xgb_train:.4f}")
print(f"  R² test (Тестова вибірка):    {r2_xgb_test:.4f}")
print(f"  MAE test (Середня абсолютна помилка):  {mae_xgb_test:.4f}")
print(f"  RMSE test (Корінь із середньоквадратичної): {rmse_xgb_test:.4f}")
print(f"  Час навчання: {xgb_time:.2f}s")

print(f"\n📊 Порівняння з іншими ансамблями:")
print(f"  XGBoost швидший за sklearn GB у: {gb_time / xgb_time:.1f}× разів")
print(f"  Приріст R² тестового порівняно з sklearn GB: +{(r2_xgb_test - r2_gb_test) * 100:.2f}%")
print(f"  Приріст R² тестового порівняно з Random Forest: +{(r2_xgb_test - r2_rf_test) * 100:.2f}%")

from sklearn.model_selection import GridSearchCV
from xgboost import XGBRegressor

# Підбір гіперпараметрів через GridSearchCV (Пошук по сітці)
param_grid = {
    'n_estimators': [100, 200, 300],
    'learning_rate': [0.05, 0.1],
    'max_depth': [3, 5, 7],
    'subsample': [0.8, 1.0]
}

grid_search = GridSearchCV(
    XGBRegressor(random_state=42, n_jobs=-1),
    param_grid,
    cv=3,
    scoring='r2',
    n_jobs=-1,
    verbose=1
)

grid_search.fit(X_train, y_train)

print("🔍 Результати GridSearchCV:")
print(f"  Найкращі параметри: {grid_search.best_params_}")
print(f"  R² CV (Крос-валідаційний бал): {grid_search.best_score_:.4f}")

# Оцінка на тестовій вибірці (Test)
best_xgb = grid_search.best_estimator_
r2_test = best_xgb.score(X_test, y_test)
print(f"  R² test (Фінальний тестовий бал): {r2_test:.4f}")

# Early stopping (Рання зупинка): зупинка, якщо якість не покращується
xgb_early = XGBRegressor(
    n_estimators=1000,         # великий початковий ліміт дерев
    learning_rate=0.05,        # плавний низький темп навчання
    max_depth=5,
    early_stopping_rounds=10,  # зупинка після 10 ітерацій без покращення
    random_state=42
)

xgb_early.fit(
    X_train, y_train,
    eval_set=[(X_test, y_test)],  # моніторинг помилки на test
    verbose=False
)

print("🛑 Early Stopping (Рання зупинка):")
print(f"  Зупинилось на ітерації (best_iteration): {xgb_early.best_iteration}")
print(f"  R² test (Тестова якість): {xgb_early.score(X_test, y_test):.4f}")
print(f"\n💡 Замість 1000 дерев алгоритм навчив лише {xgb_early.best_iteration} → економія понад 25% часу!")

import pandas as pd
from xgboost import XGBRegressor
from sklearn.ensemble import RandomForestRegressor

# Отримання важливостей ознак для Random Forest та XGBoost
importances_rf = rf.feature_importances_
importances_xgb = xgb.feature_importances_

# Двомовний словник найменувань ознак датасету California Housing
feature_names_en = list(X.columns)
feature_names_ua = [
    'MedInc (Медіанний дохід жителів)',
    'HouseAge (Середній вік будинків)',
    'AveRooms (Середня кількість кімнат)',
    'AveBedrms (Середня кількість спалень)',
    'Population (Чисельність населення)',
    'AveOccup (Середня заселеність житла)',
    'Latitude (Географічна широта)',
    'Longitude (Географічна довгота)'
]

comparison_df = pd.DataFrame({
    'Feature': feature_names_en,
    'Bilingual_Label': feature_names_ua,
    'RF_Importance': importances_rf,
    'XGB_Importance': importances_xgb
}).sort_values('XGB_Importance', ascending=False)

print("📊 Порівняння важливості ознак (Random Forest vs XGBoost):\n")
for _, row in comparison_df.iterrows():
    print(f"  {row['Bilingual_Label']:42s} | RF: {row['RF_Importance']*100:4.1f}% | XGB: {row['XGB_Importance']*100:4.1f}%")