from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import cross_val_score
import numpy as np

# Ті самі дані, різні гіперпараметри
configs = [
    {"n_estimators": 10, "max_depth": 3},
    {"n_estimators": 100, "max_depth": 10},
    {"n_estimators": 100, "max_depth": None},
    {"n_estimators": 500, "max_depth": 15},
]

print("Конфігурація                | CV Score (RMSE)")
print("-" * 50)

for config in configs:
    rf = RandomForestRegressor(**config, random_state=42)
    scores = cross_val_score(rf, X_train, y_train,
                            cv=5, scoring='neg_root_mean_squared_error')
    rmse = -scores.mean()
    print(f"trees={config['n_estimators']:3}, depth={str(config['max_depth']):4} | {rmse:.2f} піц")

Конфігурація                | CV Score (RMSE)
--------------------------------------------------
trees= 10, depth=3    | 12.4 піц
trees=100, depth=10   |  9.1 піц
trees=100, depth=None |  8.7 піц
trees=500, depth=15   |  8.2 піц

n_estimators:    [100, 200, 300]
max_depth:       [5, 10, 15]
                    ↓
Grid Search пробує ВСІ 9 комбінацій:
(100,5), (100,10), (100,15),
(200,5), (200,10), (200,15),
(300,5), (300,10), (300,15)

from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestRegressor

# Визначаємо сітку параметрів
param_grid = {
    'n_estimators': [100, 200, 300],
    'max_depth': [5, 10, 15, None],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4]
}

# Створюємо модель
rf = RandomForestRegressor(random_state=42)

# Налаштовуємо Grid Search з 5-fold крос-валідацією
grid_search = GridSearchCV(
    estimator=rf,
    param_grid=param_grid,
    cv=5,                          # 5-fold крос-валідація
    scoring='neg_root_mean_squared_error',
    n_jobs=-1,                     # Використовувати всі ядра CPU
    verbose=2                      # Показувати прогрес
)

# Запускаємо пошук
grid_search.fit(X_train, y_train)

# Результати
print(f"Найкращі параметри: {grid_search.best_params_}")
print(f"Найкращий CV RMSE: {-grid_search.best_score_:.2f} піц")

Fitting 5 folds for each of 144 candidates, totalling 720 fits
Найкращі параметри: {'max_depth': 15, 'min_samples_leaf': 2,
                      'min_samples_split': 5, 'n_estimators': 200}
Найкращий CV RMSE: 7.8 піц

Grid Search (9 точок):         Random Search (9 точок):
●───●───●                      ●     ●   ●
│   │   │                        ●       ●
●───●───●                      ●   ●
│   │   │                            ●   ●
●───●───●                        ●

Grid: 3 унікальних значення    Random: 9 унікальних значень
для важливого параметра        для важливого параметра!

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

# Визначаємо розподіли параметрів (не просто списки!)
param_distributions = {
    'n_estimators': randint(50, 500),        # Випадкове ціле 50-500
    'max_depth': randint(3, 30),             # Випадкове ціле 3-30
    'min_samples_split': randint(2, 20),     # Випадкове ціле 2-20
    'min_samples_leaf': randint(1, 10),      # Випадкове ціле 1-10
    'max_features': uniform(0.1, 0.9),       # Випадкове дробове 0.1-1.0
}

rf = RandomForestRegressor(random_state=42)

# Random Search зі 100 ітераціями
random_search = RandomizedSearchCV(
    estimator=rf,
    param_distributions=param_distributions,
    n_iter=100,                    # Спробувати 100 випадкових комбінацій
    cv=5,
    scoring='neg_root_mean_squared_error',
    n_jobs=-1,
    random_state=42,
    verbose=1
)

random_search.fit(X_train, y_train)

print(f"Найкращі параметри: {random_search.best_params_}")
print(f"Найкращий CV RMSE: {-random_search.best_score_:.2f} піц")

Fitting 5 folds for each of 100 candidates, totalling 500 fits
Найкращі параметри: {'max_depth': 18, 'max_features': 0.42,
                      'min_samples_leaf': 3, 'min_samples_split': 8,
                      'n_estimators': 287}
Найкращий CV RMSE: 7.5 піц

# Grid Search: 144 комбінації
# Random Search: 100 випадкових вибірок

print(f"{'Метод':<15} {'Комбінацій':>12} {'Час':>10} {'Найкращий RMSE':>15}")
print("-" * 55)
print(f"{'Grid Search':<15} {144:>12} {'2.1 год':>10} {7.8:>13.2f}")
print(f"{'Random Search':<15} {100:>12} {'1.4 год':>10} {7.5:>13.2f}")

import optuna
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import cross_val_score

def objective(trial):
    """Optuna викликатиме цю функцію багато разів з різними параметрами"""

    # Пропонуємо гіперпараметри
    params = {
        'n_estimators': trial.suggest_int('n_estimators', 50, 500),
        'max_depth': trial.suggest_int('max_depth', 3, 30),
        'min_samples_split': trial.suggest_int('min_samples_split', 2, 20),
        'min_samples_leaf': trial.suggest_int('min_samples_leaf', 1, 10),
        'max_features': trial.suggest_float('max_features', 0.1, 1.0),
    }

    # Навчаємо та оцінюємо
    rf = RandomForestRegressor(**params, random_state=42, n_jobs=-1)
    scores = cross_val_score(rf, X_train, y_train,
                            cv=5, scoring='neg_root_mean_squared_error')

    return -scores.mean()  # Optuna мінімізує, тому повертаємо додатний RMSE

# Створюємо дослідження та оптимізуємо
study = optuna.create_study(direction='minimize')
study.optimize(objective, n_trials=50, show_progress_bar=True)

print(f"Найкращі параметри: {study.best_params}")
print(f"Найкращий CV RMSE: {study.best_value:.2f} піц")

[I 2025-01-12 10:30:00] Trial 0 finished with value: 9.2
[I 2025-01-12 10:30:15] Trial 1 finished with value: 8.8
...
[I 2025-01-12 10:45:00] Trial 49 finished with value: 7.1

Найкращі параметри: {'n_estimators': 312, 'max_depth': 21,
                      'min_samples_split': 6, 'min_samples_leaf': 2,
                      'max_features': 0.58}
Найкращий CV RMSE: 7.1 піц

results = {
    'Grid Search':        {'trials': 144, 'time': '2.1 год', 'rmse': 7.8},
    'Random Search':      {'trials': 100, 'time': '1.4 год', 'rmse': 7.5},
    'Bayesian (Optuna)':  {'trials': 50,  'time': '0.8 год', 'rmse': 7.1},
}

print(f"{'Метод':<20} {'Спроб':>8} {'Час':>10} {'Найкращий RMSE':>15}")
print("-" * 55)
for method, data in results.items():
    print(f"{method:<20} {data['trials']:>8} {data['time']:>10} {data['rmse']:>13.1f}")

Метод                  Спроб        Час   Найкращий RMSE
-------------------------------------------------------
Grid Search              144    2.1 год            7.8
Random Search            100    1.4 год            7.5
Bayesian (Optuna)         50    0.8 год            7.1

# Після інтенсивного налаштування...
best_model = grid_search.best_estimator_

# Валідаційний скор (використовувався під час налаштування)
val_rmse = -grid_search.best_score_
print(f"Validation RMSE: {val_rmse:.2f}")  # 7.1 піц

# СПРАВЖНІЙ тестовий скор (повністю відкладений)
test_pred = best_model.predict(X_test)
test_rmse = np.sqrt(mean_squared_error(y_test, test_pred))
print(f"Test RMSE: {test_rmse:.2f}")       # 8.3 піц 😬

Зовнішній цикл: Оцінка справжньої продуктивності
├── Fold 1: Навчання на 80%, Тест на 20%
│   └── Внутрішній цикл: Пошук найкращих гіперпараметрів на 80%
│       ├── Inner Fold 1: Навчання на 64%, Валідація на 16%
│       ├── Inner Fold 2: ...
│       └── Вибір найкращих параметрів → Оцінка на зовнішніх 20%
├── Fold 2: Інший поділ 80/20
│   └── Внутрішній цикл: Знову пошук найкращих параметрів
...

# Розбиваємо дані на ТРИ частини
X_train, X_temp, y_train, y_temp = train_test_split(X, y, test_size=0.3)
X_val, X_test, y_val, y_test = train_test_split(X_temp, y_temp, test_size=0.5)

# Використовуємо X_train + X_val для налаштування
# X_test НІКОЛИ не чіпаємо до фінальної оцінки

# Налаштовуємо на train+val
grid_search.fit(X_train, y_train)  # CV використовує X_train внутрішньо

# Фінальна чесна оцінка
final_score = grid_search.best_estimator_.score(X_test, y_test)

# Завжди спочатку встановіть базову лінію
baseline = RandomForestRegressor(random_state=42)
baseline_scores = cross_val_score(baseline, X_train, y_train, cv=5,
                                  scoring='neg_root_mean_squared_error')
print(f"Baseline RMSE: {-baseline_scores.mean():.2f}")

# Спочатку закидаємо широку сітку
coarse_params = {
    'n_estimators': randint(50, 500),
    'max_depth': randint(3, 50),
    'min_samples_split': randint(2, 30),
}

coarse_search = RandomizedSearchCV(rf, coarse_params, n_iter=30, cv=3)
coarse_search.fit(X_train, y_train)

# Визначаємо перспективні регіони
print(f"Поки що найкраще: {coarse_search.best_params_}")

# Збільшуємо масштаб на перспективних регіонах
fine_params = {
    'n_estimators': [250, 300, 350],      # Біля найкращого з грубого
    'max_depth': [15, 18, 21, 24],         # Біля найкращого з грубого
    'min_samples_split': [4, 6, 8, 10],    # Біля найкращого з грубого
}

fine_search = GridSearchCV(rf, fine_params, cv=5)
fine_search.fit(X_train, y_train)

# Чесна оцінка на тестовій вибірці
final_model = fine_search.best_estimator_
test_predictions = final_model.predict(X_test)
test_rmse = np.sqrt(mean_squared_error(y_test, test_predictions))

print(f"Фінальний Test RMSE: {test_rmse:.2f} піц")

import xgboost as xgb
import optuna

def objective(trial):
    params = {
        'n_estimators': trial.suggest_int('n_estimators', 100, 1000),
        'max_depth': trial.suggest_int('max_depth', 3, 10),
        'learning_rate': trial.suggest_float('learning_rate', 0.01, 0.3, log=True),
        'subsample': trial.suggest_float('subsample', 0.5, 1.0),
        'colsample_bytree': trial.suggest_float('colsample_bytree', 0.5, 1.0),
        'reg_alpha': trial.suggest_float('reg_alpha', 1e-8, 10, log=True),
        'reg_lambda': trial.suggest_float('reg_lambda', 1e-8, 10, log=True),
    }

    model = xgb.XGBRegressor(**params, random_state=42, n_jobs=-1)

    scores = cross_val_score(model, X_train, y_train,
                            cv=5, scoring='neg_root_mean_squared_error')

    return -scores.mean()

# Запускаємо оптимізацію
study = optuna.create_study(direction='minimize')
study.optimize(objective, n_trials=100, show_progress_bar=True)

# Навчаємо фінальну модель
best_xgb = xgb.XGBRegressor(**study.best_params, random_state=42)
best_xgb.fit(X_train, y_train)

# Оцінюємо
test_pred = best_xgb.predict(X_test)
print(f"Tuned XGBoost Test RMSE: {np.sqrt(mean_squared_error(y_test, test_pred)):.2f}")

# Неправильний підхід:
# "Давайте налаштуємо 20 гіперпараметрів протягом 3 годин"

# Правильний підхід:
# 1. Отримайте базову лінію зі значеннями за замовчуванням
# 2. Перевірте, чи тип моделі підходить
# 3. ПОТІМ налаштовуйте важливі гіперпараметри

# Замість налаштування n_estimators...
model = xgb.XGBRegressor(
    n_estimators=10000,  # Встановіть високо
    early_stopping_rounds=50,
    eval_metric='rmse'
)

model.fit(X_train, y_train,
         eval_set=[(X_val, y_val)],
         verbose=False)

print(f"Оптимальна кількість дерев: {model.best_iteration}")

# Ці комбінації часто дають схожі результати:
# - learning_rate=0.3, n_estimators=100
# - learning_rate=0.1, n_estimators=300
# - learning_rate=0.03, n_estimators=1000

# Нижчий learning rate + більше дерев = зазвичай краще, але повільніше

import pandas as pd

# Збережіть результати grid search для аналізу
results_df = pd.DataFrame(grid_search.cv_results_)
results_df.to_csv('hyperparameter_search_results.csv', index=False)

# Ви можете проаналізувати, які параметри важливіші

print("=" * 60)
print("МОДЕЛЬ ПРОГНОЗУВАННЯ ПІЦИ - ФІНАЛЬНЕ ПОРІВНЯННЯ")
print("=" * 60)

models = {
    'Базова (за замовчуванням)': 9.8,
    'Після feature engineering': 8.5,
    'Random Forest (вручну)': 7.8,
    'Random Forest (grid search)': 7.5,
    'XGBoost (Optuna tuned)': 6.4,
}

print(f"\n{'Модель':<35} {'Test RMSE':>15}")
print("-" * 52)
for model, rmse in models.items():
    print(f"{model:<35} {rmse:>12.1f} піц")

print("\n" + "=" * 60)
improvement = (9.8 - 6.4) / 9.8 * 100
print(f"Загальне покращення: {improvement:.0f}% зменшення помилки передбачення")
print(f"Від ±9.8 піц до ±6.4 піц")
print("=" * 60)

============================================================
МОДЕЛЬ ПРОГНОЗУВАННЯ ПІЦИ - ФІНАЛЬНЕ ПОРІВНЯННЯ
============================================================

Модель                                    Test RMSE
----------------------------------------------------
Базова (за замовчуванням)                     9.8 піц
Після feature engineering                     8.5 піц
Random Forest (вручну)                        7.8 піц
Random Forest (grid search)                   7.5 піц
XGBoost (Optuna tuned)                        6.4 піц

============================================================
Загальне покращення: 35% зменшення помилки передбачення
Від ±9.8 піц до ±6.4 піц
============================================================