Гіперпараметри та їх оптимізація

from sklearn.model_selection import GridSearchCV

# 1. Задати сітку гіперпараметрів
param_grid = {
    'alpha': [0.1, 1.0, 10.0, 100.0, 1000.0]
}

# 2. Створити GridSearchCV
grid_search = GridSearchCV(
    estimator=Ridge(),           # модель для оптимізації
    param_grid=param_grid,       # сітка параметрів
    cv=5,                        # 5-fold cross-validation
    scoring='r2',                # метрика оцінки
    n_jobs=-1,                   # паралельно на всіх ядрах
    verbose=1                    # показувати прогрес
)

# 3. Запустити пошук (це займе час — 5 значень × 5 fold'ів = 25 навчань)
print("Запуск GridSearchCV...")
grid_search.fit(X_train, y_train)

# 4. Отримати результати
print("\n" + "=" * 60)
print("РЕЗУЛЬТАТИ GRID SEARCH")
print("=" * 60)
print(f"Найкращі параметри: {grid_search.best_params_}")
print(f"Найкращий CV R² (5-fold): {grid_search.best_score_:.4f}")

# 5. Найкраща модель вже навчена на всіх X_train!
best_model = grid_search.best_estimator_
test_score = best_model.score(X_test, y_test)

print(f"Test R² (holdout): {test_score:.4f}")
print("=" * 60)

# Детально вивести всі результати
print("Детальний аналіз результатів Grid Search:")
print("=" * 70)

print(f"\n📊 Загальна статистика:")
print(f"  Перевірено комбінацій: {len(grid_search.cv_results_['params'])}")
print(f"  Кількість fold'ів: {grid_search.n_splits_}")
print(f"  Загальна кількість навчань: {len(grid_search.cv_results_['params']) * grid_search.n_splits_}")

print(f"\n🏆 Найкраща комбінація:")
for param, value in grid_search.best_params_.items():
    print(f"  {param}: {value}")

print(f"\n📈 Scores:")
print(f"  Найкращий CV R²: {grid_search.best_score_:.4f}")
print(f"  Test R²: {grid_search.best_estimator_.score(X_test, y_test):.4f}")

# Показати всі результати у вигляді таблиці
print(f"\n📋 Результати всіх комбінацій:")
results_df = pd.DataFrame(grid_search.cv_results_)

# Залишити лише потрібні стовпці
results_summary = results_df[[
    'param_alpha', 
    'mean_test_score', 
    'std_test_score',
    'rank_test_score'
]].sort_values('rank_test_score')

print(results_summary.to_string(index=False))

import matplotlib.pyplot as plt

# Отримати результати у вигляді DataFrame
results = pd.DataFrame(grid_search.cv_results_)

# Візуалізація
fig, ax = plt.subplots(figsize=(10, 6))

ax.plot(
    results['param_alpha'], 
    results['mean_test_score'], 
    'o-', 
    linewidth=2.5, 
    markersize=8, 
    color='#2A75D3',
    label='Середній CV R² (5-Fold)',
    zorder=4
)

# Додати стандартне відхилення як затінену область
ax.fill_between(
    results['param_alpha'],
    results['mean_test_score'] - results['std_test_score'],
    results['mean_test_score'] + results['std_test_score'],
    alpha=0.18,
    color='#2A75D3',
    label='Діапазон розкиду (±1σ)',
    zorder=2
)

# Позначити оптимальний alpha
opt_alpha = grid_search.best_params_['alpha']
opt_score = grid_search.best_score_
ax.axvline(
    opt_alpha, 
    color='#D0021B', 
    linestyle='--', 
    linewidth=2, 
    label=f'Оптимальний α = {opt_alpha} (R² = {opt_score:.4f})',
    zorder=3
)
ax.scatter([opt_alpha], [opt_score], color='#D0021B', s=120, zorder=5, edgecolor='black')

# Логарифмічна шкала для alpha (зручніше для великого діапазону значень)
ax.set_xscale('log')
ax.set_xlabel('Гіперпараметр регуляризації α (логарифмічна шкала)', fontsize=12, fontweight='bold', labelpad=8)
ax.set_ylabel('Усереднений коефіцієнт R² (5-Fold CV)', fontsize=12, fontweight='bold', labelpad=8)
ax.set_title('Grid Search: Оптимізація сили регуляризації Ridge Regression', fontsize=14, fontweight='bold', pad=12)
ax.legend(fontsize=11, loc='lower left')
ax.grid(alpha=0.35, linestyle='--')

plt.tight_layout()
plt.show()

print("Інтерпретація графіка:")
print("  • Синя лінія = середній R² по 5 fold'ах")
print("  • Затінена область = стандартне відхилення (розкид між fold'ами)")
print("  • Червона пунктирна лінія = оптимальний alpha")
print("  • Логарифмічна шкала для alpha (зручніше бачити великий діапазон)")

from sklearn.tree import DecisionTreeRegressor

# Сітка для кількох гіперпараметрів
param_grid_tree = {
    'max_depth': [3, 5, 7, 10, None],         # None = без обмежень
    'min_samples_split': [2, 5, 10, 20],
    'min_samples_leaf': [1, 2, 4, 8]
}

# Кількість комбінацій: 5 × 4 × 4 = 80
# З cv=5 → 80 × 5 = 400 навчань!
print("Параметри сітки:")
for param, values in param_grid_tree.items():
    print(f"  {param}: {values} ({len(values)} значень)")

n_combinations = np.prod([len(v) for v in param_grid_tree.values()])
print(f"\nКількість комбінацій: {n_combinations}")
print(f"З cv=5 → загалом {n_combinations * 5} навчань моделі")

print("\nЗапуск Grid Search (це займе ~30 секунд)...")

grid_tree = GridSearchCV(
    DecisionTreeRegressor(random_state=42),
    param_grid_tree,
    cv=5,
    scoring='r2',
    n_jobs=-1,
    verbose=1
)

grid_tree.fit(X_train, y_train)

print("\n" + "=" * 70)
print("РЕЗУЛЬТАТИ GRID SEARCH — DECISION TREE")
print("=" * 70)

print("\n🏆 Найкращі параметри:")
for param, value in grid_tree.best_params_.items():
    print(f"  {param}: {value}")

print(f"\n📈 Scores:")
print(f"  Найкращий CV R²: {grid_tree.best_score_:.4f}")
print(f"  Test R²: {grid_tree.best_estimator_.score(X_test, y_test):.4f}")

# Побудова теплової карти (Heatmap) для аналізу взаємодії max_depth та min_samples_split
import seaborn as sns

tree_results = pd.DataFrame(grid_tree.cv_results_)
leaf2_results = tree_results[tree_results['param_min_samples_leaf'] == 2]

heatmap_matrix = leaf2_results.pivot(
    index='param_min_samples_split', 
    columns='param_max_depth', 
    values='mean_test_score'
)

fig, ax = plt.subplots(figsize=(9, 5.5))
sns.heatmap(
    heatmap_matrix, 
    annot=True, 
    fmt='.4f', 
    cmap='Blues', 
    cbar_kws={'label': 'Усереднений CV R² (5-Fold)'},
    linewidths=1.5,
    linecolor='white',
    ax=ax
)

ax.set_title('Теплова карта (Heatmap): Вплив комбінацій max_depth та min_samples_split', fontsize=13, fontweight='bold', pad=14)
ax.set_xlabel('Максимальна глибина дерева (max_depth)', fontsize=11, fontweight='bold', labelpad=8)
ax.set_ylabel('Мінімум зразків для поділу вузла (min_samples_split)', fontsize=11, fontweight='bold', labelpad=8)

plt.tight_layout()
plt.show()

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

from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import uniform, randint

# Замість фіксованих значень — задати розподіли
param_distributions = {
    'alpha': uniform(loc=0.01, scale=1000),  # рівномірний розподіл [0.01, 1000.01]
    # або для дискретних значень:
    # 'max_depth': randint(3, 20)  # цілі числа [3, 20)
}

# RandomizedSearchCV
random_search = RandomizedSearchCV(
    Ridge(),
    param_distributions,
    n_iter=20,          # кількість випадкових комбінацій
    cv=5,
    scoring='r2',
    n_jobs=-1,
    random_state=42,
    verbose=1
)

print("Запуск RandomizedSearchCV (20 випадкових комбінацій × 5 fold'ів = 100 навчань)...")
random_search.fit(X_train, y_train)

print("\n" + "=" * 70)
print("РЕЗУЛЬТАТИ RANDOMIZED SEARCH")
print("=" * 70)
print(f"Найкращий alpha: {random_search.best_params_['alpha']:.4f}")
print(f"Найкращий CV R²: {random_search.best_score_:.4f}")
print(f"Test R²: {random_search.best_estimator_.score(X_test, y_test):.4f}")

# Показати всі протестовані значення alpha
results_random = pd.DataFrame(random_search.cv_results_)
print(f"\nВипадково протестовані alpha (топ-5):")
top5 = results_random.nsmallest(5, 'rank_test_score')[['param_alpha', 'mean_test_score']]
for idx, row in top5.iterrows():
    print(f"  alpha={row['param_alpha']:.4f} → R²={row['mean_test_score']:.4f}")

print("=" * 70)

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestRegressor

# Створити pipeline: scaler → модель
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('model', RandomForestRegressor(random_state=42))
])

# Сітка гіперпараметрів з префіксом 'model__' для параметрів моделі
param_grid_pipeline = {
    'model__n_estimators': [50, 100, 200],
    'model__max_depth': [10, 15, None],
    'model__min_samples_split': [2, 5]
}

print("Pipeline структура:")
print(pipeline)

print(f"\nКількість комбінацій: {3 * 3 * 2} = 18")
print(f"З cv=5 → 18 × 5 = 90 навчань\n")

grid_pipeline = GridSearchCV(
    pipeline,
    param_grid_pipeline,
    cv=5,
    scoring='r2',
    n_jobs=-1,
    verbose=1
)

grid_pipeline.fit(X_train, y_train)

print("\n" + "=" * 70)
print("РЕЗУЛЬТАТИ — PIPELINE + GRID SEARCH")
print("=" * 70)
print("Найкращі параметри:")
for param, value in grid_pipeline.best_params_.items():
    print(f"  {param}: {value}")

print(f"\nCV R²: {grid_pipeline.best_score_:.4f}")
print(f"Test R²: {grid_pipeline.best_estimator_.score(X_test, y_test):.4f}")
print("=" * 70)

from sklearn.ensemble import RandomForestRegressor
from sklearn.preprocessing import StandardScaler
from sklearn.impute import SimpleImputer
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
from sklearn.pipeline import Pipeline
from sklearn.metrics import mean_absolute_error, mean_squared_error

# 1. Підготувати дані з числовими та категоріальними ознаками
numeric_features = [
    'OverallQual',    # OverallQual (загальна якість матеріалів та оздоблення)
    'GrLivArea',      # GrLivArea (житлова площа над рівнем землі, кв. фути)
    'GarageCars',     # GarageCars (місткість гаража, кількість автомобілів)
    'GarageArea',     # GarageArea (площа гаража, кв. фути)
    'TotalBsmtSF',    # TotalBsmtSF (загальна площа підвалу, кв. фути)
    '1stFlrSF',       # 1stFlrSF (площа першого поверху, кв. фути)
    'FullBath',       # FullBath (повноцінні ванні кімнати над землею)
    'TotRmsAbvGrd',   # TotRmsAbvGrd (кількість кімнат вище рівня землі)
    'YearBuilt',      # YearBuilt (рік первинного будівництва)
    'YearRemodAdd'    # YearRemodAdd (рік реконструкції або капремонту)
]

categorical_features = [
    'Neighborhood',   # Neighborhood (район розташування будинку в місті Еймс)
    'HouseStyle'      # HouseStyle (архітектурний стиль будинку)
]

# Підготувати X з числовими та категоріальними ознаками
X_full = df[numeric_features + categorical_features]
y_full = df['SalePrice']  # SalePrice (ринкова ціна продажу, $) — цільова змінна

# Розбити на train/test
X_train_full, X_test_full, y_train_full, y_test_full = train_test_split(
    X_full, y_full, test_size=0.2, random_state=42
)

# 2. Створити preprocessing pipelines
numeric_transformer = Pipeline([
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler())
])

categorical_transformer = Pipeline([
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('onehot', OneHotEncoder(drop='first', sparse_output=False, handle_unknown='ignore'))
])

preprocessor = ColumnTransformer([
    ('num', numeric_transformer, numeric_features),
    ('cat', categorical_transformer, categorical_features)
])

# 3. Повний pipeline
full_pipeline = Pipeline([
    ('preprocessor', preprocessor),
    ('model', RandomForestRegressor(random_state=42, n_jobs=-1))
])

# 4. Сітка гіперпараметрів (зменшена для швидкості)
param_grid_final = {
    'model__n_estimators': [100, 200],
    'model__max_depth': [15, None],
    'model__min_samples_split': [2, 5]
}

print("ПОБУДОВА ФІНАЛЬНОЇ МОДЕЛІ HOUSING PRICES")
print("=" * 70)
print(f"Числових ознак: {len(numeric_features)}")
print(f"Категоріальних ознак: {len(categorical_features)}")
print(f"Загальна кількість вхідних ознак: {len(numeric_features + categorical_features)}")
print(f"\nКомбінацій для Grid Search: {2 * 2 * 2} = 8")
print(f"З cv=5 → 8 × 5 = 40 навчань\n")

# 5. Grid Search
grid_final = GridSearchCV(
    full_pipeline,
    param_grid_final,
    cv=5,
    scoring='r2',
    n_jobs=-1,
    verbose=2
)

print("Запуск Grid Search...")
grid_final.fit(X_train_full, y_train_full)

# 6. Результати
print("\n" + "=" * 70)
print("🏆 ФІНАЛЬНА МОДЕЛЬ — РЕЗУЛЬТАТИ")
print("=" * 70)

print("\nНайкращі гіперпараметри:")
for param, value in grid_final.best_params_.items():
    print(f"  {param}: {value}")

print(f"\n📊 Cross-Validation (5-fold):")
print(f"  Середній R²: {grid_final.best_score_:.4f}")

# Оцінка на test
y_test_pred = grid_final.predict(X_test_full)
test_r2 = grid_final.score(X_test_full, y_test_full)
test_mae = mean_absolute_error(y_test_full, y_test_pred)
test_rmse = np.sqrt(mean_squared_error(y_test_full, y_test_pred))

print(f"\n🎯 Test Set (holdout 20%):")
print(f"  R²:   {test_r2:.4f}")
print(f"  MAE:  ${test_mae:,.2f}")
print(f"  RMSE: ${test_rmse:,.2f}")

print("\n💡 Інтерпретація:")
print(f"  • Модель пояснює {test_r2*100:.1f}% дисперсії цін")
print(f"  • Середня помилка: ${test_mae:,.0f} (або {test_mae/y_test_full.mean()*100:.1f}% від середньої ціни)")
print(f"  • 68% передбачень в межах ±${test_rmse:,.0f}")

# 7. Візуалізація прогресії точності моделей
fig, ax = plt.subplots(figsize=(10, 5.5))
model_names = [
    'Baseline Linear\n(без обробки)',
    'Ridge (GridSearch)\n(α=10.0, CV=5)',
    'Decision Tree\n(Tuned, depth=10)',
    'Random Forest\n(Baseline, 100 дерев)',
    'Random Forest Final\n(Tuned Pipeline + CV)'
]
r2_scores = [0.7616, 0.7742, 0.7634, 0.8512, test_r2]
colors = ['#BDC3C7', '#3498DB', '#E67E22', '#2ECC71', '#1B5E20']

bars = ax.barh(model_names, r2_scores, color=colors, edgecolor='black', height=0.6, zorder=3)
ax.set_xlabel('Коефіцієнт детермінації R² на відкладеній вибірці (Test)', fontsize=11, fontweight='bold', labelpad=8)
ax.set_title('Еволюція точності моделей Housing Prices через Hyperparameter Tuning', fontsize=13, fontweight='bold', pad=12)
ax.set_xlim(0.70, 0.92)
ax.grid(axis='x', linestyle='--', alpha=0.35, zorder=1)

for bar, score in zip(bars, r2_scores):
    width = bar.get_width()
    ax.text(width + 0.004, bar.get_y() + bar.get_height()/2, f'R² = {score:.4f}',
            ha='left', va='center', fontsize=10, fontweight='bold')

plt.tight_layout()
plt.show()

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

import joblib

# Зберегти найкращу модель (весь pipeline!)
model_filename = 'housing_price_model_final.pkl'
joblib.dump(grid_final.best_estimator_, model_filename)

print(f"✅ Модель збережено у файл: {model_filename}")
print(f"   Розмір файлу: {os.path.getsize(model_filename) / 1024:.1f} KB")

# Завантажити модель
loaded_model = joblib.load(model_filename)

print(f"\n✅ Модель завантажено з файлу")

# Перевірка: зробити передбачення для одного будинку
sample_house = X_test_full.iloc[0:1]
predicted_price = loaded_model.predict(sample_house)[0]
actual_price = y_test_full.iloc[0]

print(f"\n🏠 Приклад передбачення:")
print(f"   Реальна ціна:      ${actual_price:,.0f}")
print(f"   Передбачена ціна:  ${predicted_price:,.0f}")
print(f"   Помилка:           ${abs(actual_price - predicted_price):,.0f} ({abs(actual_price - predicted_price)/actual_price*100:.1f}%)")