Крос-валідація (Cross-Validation)

# Візуалізуємо розподіл цін для "найкращого" та "найгіршого" split
import matplotlib.pyplot as plt

fig, axes = plt.subplots(1, 2, figsize=(14, 5))

# Найкращий split (seed=6, R²=0.8256)
X_train_best, X_test_best, y_train_best, y_test_best = train_test_split(
    X, y, test_size=0.2, random_state=6
)

axes[0].hist(y_train_best, bins=30, alpha=0.6, label='Train', color='dodgerblue', edgecolor='black')
axes[0].hist(y_test_best, bins=15, alpha=0.7, label='Test', color='limegreen', edgecolor='black')
axes[0].axvline(y_train_best.mean(), color='blue', linestyle='--', linewidth=2, label=f'Train mean: ${y_train_best.mean()/1000:.0f}k')
axes[0].axvline(y_test_best.mean(), color='green', linestyle='--', linewidth=2, label=f'Test mean: ${y_test_best.mean()/1000:.0f}k')
axes[0].set_xlabel('Ціна ($)', fontsize=11, fontweight='bold')
axes[0].set_ylabel('Частота', fontsize=11, fontweight='bold')
axes[0].set_title('Найкращий split (seed=6, R²=0.826)', fontsize=12, fontweight='bold', color='green')
axes[0].legend(fontsize=9)
axes[0].grid(alpha=0.3, linestyle='--')

# Найгірший split (seed=7, R²=0.7534)
X_train_worst, X_test_worst, y_train_worst, y_test_worst = train_test_split(
    X, y, test_size=0.2, random_state=7
)

axes[1].hist(y_train_worst, bins=30, alpha=0.6, label='Train', color='dodgerblue', edgecolor='black')
axes[1].hist(y_test_worst, bins=15, alpha=0.7, label='Test', color='orange', edgecolor='black')
axes[1].axvline(y_train_worst.mean(), color='blue', linestyle='--', linewidth=2, label=f'Train mean: ${y_train_worst.mean()/1000:.0f}k')
axes[1].axvline(y_test_worst.mean(), color='red', linestyle='--', linewidth=2, label=f'Test mean: ${y_test_worst.mean()/1000:.0f}k')
axes[1].set_xlabel('Ціна ($)', fontsize=11, fontweight='bold')
axes[1].set_ylabel('Частота', fontsize=11, fontweight='bold')
axes[1].set_title('Найгірший split (seed=7, R²=0.753)', fontsize=12, fontweight='bold', color='red')
axes[1].legend(fontsize=9)
axes[1].grid(alpha=0.3, linestyle='--')

plt.tight_layout()
plt.show()

print(f"Найкращий split:")
print(f"  Train mean: ${y_train_best.mean():,.0f}, Test mean: ${y_test_best.mean():,.0f}")
print(f"  Різниця: ${abs(y_train_best.mean() - y_test_best.mean()):,.0f}")
print()
print(f"Найгірший split:")
print(f"  Train mean: ${y_train_worst.mean():,.0f}, Test mean: ${y_test_worst.mean():,.0f}")
print(f"  Різниця: ${abs(y_train_worst.mean() - y_test_worst.mean()):,.0f}")

from sklearn.model_selection import cross_val_score

# Створити модель
model = LinearRegression()

# Виконати 5-fold cross-validation
scores = cross_val_score(
    estimator=model,      # модель для оцінки
    X=X,                  # всі ознаки
    y=y,                  # всі цільові значення
    cv=5,                 # кількість fold'ів
    scoring='r2',         # метрика (R²)
    n_jobs=-1             # використати всі CPU ядра (паралельно)
)

print("Результати 5-Fold Cross-Validation:")
print("=" * 50)
print(f"R² по fold'ам:")
for i, score in enumerate(scores, 1):
    print(f"  Fold {i}: {score:.4f}")

print("\n" + "=" * 50)
print(f"Середнє R²:        {scores.mean():.4f}")
print(f"Стандартне відхил: {scores.std():.4f}")
print(f"95% довірчий інт.: [{scores.mean() - 2*scores.std():.4f}, {scores.mean() + 2*scores.std():.4f}]")
print("=" * 50)

# Оцінити модель за трьома метриками одночасно
metrics = {
    'R²': 'r2',
    'MAE': 'neg_mean_absolute_error',
    'RMSE': 'neg_root_mean_squared_error'
}

print("=" * 60)
print("ОЦІНКА МОДЕЛІ ЗА РІЗНИМИ МЕТРИКАМИ (5-Fold CV)")
print("=" * 60)

for metric_name, scoring in metrics.items():
    scores = cross_val_score(
        model, X, y, cv=5, scoring=scoring, n_jobs=-1
    )
    
    # Для помилок перетворити на позитивні значення
    if 'neg' in scoring:
        mean_val = -scores.mean()
        std_val = scores.std()
        print(f"{metric_name:5s} = ${mean_val:>10,.2f} ± ${std_val:>8,.2f}")
    else:
        mean_val = scores.mean()
        std_val = scores.std()
        print(f"{metric_name:5s} = {mean_val:>12.4f} ± {std_val:>10.4f}")

print("=" * 60)

from sklearn.model_selection import LeaveOneOut

# Для демонстрації візьмемо лише перші 50 зразків (інакше дуже довго)
X_small = X.head(50)
y_small = y.head(50)

# Leave-One-Out Cross-Validation
loo = LeaveOneOut()

scores_loo = cross_val_score(
    model, X_small, y_small, cv=loo, scoring='r2', n_jobs=-1
)

print(f"Leave-One-Out Cross-Validation (n={len(X_small)} зразків)")
print(f"Кількість ітерацій: {loo.get_n_splits(X_small)}")
print(f"Середнє R²: {scores_loo.mean():.4f}")
print(f"Std: {scores_loo.std():.4f}")

print(f"\n⚠️ Для повного датасету (1460 зразків) це було б {1460} навчань моделі!")

from sklearn.model_selection import cross_validate

# Виконати розширену крос-валідацію
results = cross_validate(
    estimator=model,
    X=X,
    y=y,
    cv=5,
    scoring='r2',
    return_train_score=True,   # додатково повернути train scores
    n_jobs=-1
)

# Вивести результати
print("=" * 60)
print("РОЗШИРЕНА КРОС-ВАЛІДАЦІЯ (cross_validate)")
print("=" * 60)

print("\nTest R²:")
for i, score in enumerate(results['test_score'], 1):
    print(f"  Fold {i}: {score:.4f}")
print(f"\nСереднє:  {results['test_score'].mean():.4f} ± {results['test_score'].std():.4f}")

print("\nTrain R²:")
for i, score in enumerate(results['train_score'], 1):
    print(f"  Fold {i}: {score:.4f}")
print(f"\nСереднє:  {results['train_score'].mean():.4f} ± {results['train_score'].std():.4f}")

print("\nЧас виконання:")
print(f"  Навчання:    {results['fit_time'].sum():.3f}s (середнє {results['fit_time'].mean():.3f}s/fold)")
print(f"  Передбачення: {results['score_time'].sum():.3f}s (середнє {results['score_time'].mean():.3f}s/fold)")
print(f"  Загалом:     {results['fit_time'].sum() + results['score_time'].sum():.3f}s")

print("\n" + "=" * 60)

# Перевірка на overfitting
train_test_gap = results['train_score'].mean() - results['test_score'].mean()
print(f"Різниця Train vs Test: {train_test_gap:.4f}")

if train_test_gap > 0.10:
    print("⚠️  Велика різниця → підозра на overfitting")
elif train_test_gap < 0.05:
    print("✅ Маленька різниця → модель узагальнює добре")
else:
    print("📊 Помірна різниця → в межах норми")

from sklearn.linear_model import Ridge
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor

# Підготувати моделі для порівняння
models = {
    'LinearRegression': LinearRegression(),
    'Ridge (α=1.0)': Ridge(alpha=1.0),
    'Ridge (α=10.0)': Ridge(alpha=10.0),
    'DecisionTree': DecisionTreeRegressor(max_depth=8, random_state=42),
    'RandomForest': RandomForestRegressor(n_estimators=100, max_depth=15, random_state=42, n_jobs=-1)
}

# Оцінити кожну модель через 5-fold CV
results_cv = {}

print("=" * 70)
print("ПОРІВНЯННЯ МОДЕЛЕЙ (5-Fold Cross-Validation)")
print("=" * 70)
print(f"{'Модель':<25s} {'Середнє R²':>15s} {'±Std':>12s} {'Час':>12s}")
print("-" * 70)

for name, model in models.items():
    cv_results = cross_validate(
        model, X, y, cv=5, scoring='r2', n_jobs=-1, return_train_score=False
    )
    
    results_cv[name] = cv_results['test_score']
    
    mean_score = cv_results['test_score'].mean()
    std_score = cv_results['test_score'].std()
    total_time = cv_results['fit_time'].sum() + cv_results['score_time'].sum()
    
    print(f"{name:<25s} {mean_score:>15.4f} {std_score:>12.4f} {total_time:>11.3f}s")

print("=" * 70)

# Знайти найкращу модель
best_model = max(results_cv, key=lambda k: results_cv[k].mean())
best_score = results_cv[best_model].mean()
print(f"\n🏆 Найкраща модель: {best_model} (R² = {best_score:.4f})")

import matplotlib.pyplot as plt

# Побудувати box plot
fig, ax = plt.subplots(figsize=(12, 6))

ax.boxplot(
    results_cv.values(),
    tick_labels=results_cv.keys(),
    patch_artist=True,
    boxprops=dict(facecolor='dodgerblue', alpha=0.6, edgecolor='black', linewidth=1.5),
    whiskerprops=dict(color='black', linewidth=1.2),
    capprops=dict(color='black', linewidth=1.2),
    medianprops=dict(color='red', linewidth=2),
    flierprops=dict(marker='o', markerfacecolor='red', markersize=8, markeredgecolor='black')
)

ax.set_ylabel('R² Score', fontsize=12, fontweight='bold')
ax.set_title('Порівняння моделей через 5-Fold Cross-Validation', fontsize=14, fontweight='bold')
ax.grid(axis='y', alpha=0.3, linestyle='--')
ax.set_ylim(0.65, 0.90)

# Додати лінію середнього для кожної моделі
means = [results_cv[name].mean() for name in results_cv.keys()]
ax.plot(range(1, len(means)+1), means, 'o--', color='green', linewidth=2, markersize=8, 
        label='Середнє R²', zorder=10)

ax.legend(fontsize=10, loc='lower left')

plt.xticks(rotation=15, ha='right')
plt.tight_layout()
plt.show()

print("Інтерпретація box plot:")
print("  📦 Висота ящика (IQR) = розкид між 25% та 75% квантилями")
print("  🔴 Червона лінія всередині = медіана")
print("  🟢 Зелені точки = середнє значення")
print("  📏 Вузький ящик = стабільна модель (мала дисперсія)")
print("  📐 Широкий ящик = нестабільна модель (залежить від fold'у)")

from sklearn.model_selection import StratifiedKFold
from sklearn.datasets import make_classification

# Створити синтетичний незбалансований датасет для демонстрації
X_class, y_class = make_classification(
    n_samples=1000, 
    n_features=10, 
    n_informative=5,
    weights=[0.9, 0.1],  # 90% клас 0, 10% клас 1
    random_state=42
)

print(f"Розподіл класів:")
unique, counts = np.unique(y_class, return_counts=True)
for cls, count in zip(unique, counts):
    print(f"  Клас {cls}: {count} зразків ({count/len(y_class)*100:.1f}%)")

# Порівняти звичайний K-Fold та Stratified K-Fold
from sklearn.model_selection import KFold

print("\n" + "=" * 60)
print("ЗВИЧАЙНИЙ K-FOLD (може бути нерівномірний)")
print("=" * 60)

kf = KFold(n_splits=5, shuffle=True, random_state=42)

for i, (train_idx, test_idx) in enumerate(kf.split(X_class), 1):
    y_train_fold = y_class[train_idx]
    y_test_fold = y_class[test_idx]
    
    test_class1_pct = (y_test_fold == 1).sum() / len(y_test_fold) * 100
    print(f"Fold {i}: test має {test_class1_pct:.1f}% класу '1'")

print("\n" + "=" * 60)
print("STRATIFIED K-FOLD (завжди рівномірний)")
print("=" * 60)

skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

for i, (train_idx, test_idx) in enumerate(skf.split(X_class, y_class), 1):
    y_train_fold = y_class[train_idx]
    y_test_fold = y_class[test_idx]
    
    test_class1_pct = (y_test_fold == 1).sum() / len(y_test_fold) * 100
    print(f"Fold {i}: test має {test_class1_pct:.1f}% класу '1'")

from sklearn.model_selection import GridSearchCV

# Параметри для Ridge regression
param_grid = {
    'alpha': [0.1, 1.0, 10.0, 100.0]
}

# Внутрішній CV: GridSearch для вибору alpha
inner_cv = KFold(n_splits=3, shuffle=True, random_state=42)

grid_search = GridSearchCV(
    estimator=Ridge(),
    param_grid=param_grid,
    cv=inner_cv,        # внутрішній 3-fold
    scoring='r2',
    n_jobs=-1
)

# Зовнішній CV: оцінка узагальнення
outer_cv = KFold(n_splits=5, shuffle=True, random_state=42)

nested_scores = cross_val_score(
    estimator=grid_search,  # GridSearch як estimator
    X=X,
    y=y,
    cv=outer_cv,            # зовнішній 5-fold
    scoring='r2',
    n_jobs=-1
)

print("=" * 60)
print("NESTED CROSS-VALIDATION")
print("=" * 60)
print(f"Зовнішній CV: 5 fold'ів (оцінка узагальнення)")
print(f"Внутрішній CV: 3 fold'и (вибір alpha)")
print()
print(f"Загальна кількість навчань: {5 * 3 * len(param_grid['alpha'])} = {5*3*4}")
print(f"  (5 outer × 3 inner × 4 параметри)")
print()
print(f"Результати зовнішнього CV:")
for i, score in enumerate(nested_scores, 1):
    print(f"  Outer Fold {i}: R² = {score:.4f}")
print()
print(f"Фінальна оцінка: R² = {nested_scores.mean():.4f} ± {nested_scores.std():.4f}")
print("=" * 60)