Настройка гиперпараметров с помощью Grid Search и Random Search в Python

param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [None, 10, 20, 30],
    'min_samples_split': [2, 5, 10]
}

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV
 
model = RandomForestClassifier(random_state=42)
grid_search = GridSearchCV(
    estimator=model,
    param_grid=param_grid,
    cv=5,  # 5-кратная кросс-валидация
    n_jobs=-1,  # Использовать все доступные ядра процессора
    verbose=1
)
 
# Запуск поиска
grid_search.fit(X_train, y_train)
 
# Получение лучших параметров
best_params = grid_search.best_params_
print(f"Лучшие параметры: {best_params}")

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
 
# Предположим, у нас есть результаты GridSearchCV
results = grid_search.cv_results_
 
# Извлекаем параметры для визуализации
n_estimators = np.array([params['n_estimators'] for params in results['params']])
max_depth = np.array([params['max_depth'] if params['max_depth'] is not None else 100 
                    for params in results['params']])
 
# Создаем сетку для тепловой карты
pivot_table = np.zeros((len(np.unique(n_estimators)), len(np.unique(max_depth))))
for i, n in enumerate(np.unique(n_estimators)):
    for j, d in enumerate(np.unique(max_depth)):
        mask = (n_estimators == n) & (max_depth == d)
        if np.any(mask):
            pivot_table[i, j] = np.max(results['mean_test_score'][mask])
 
# Визуализация
plt.figure(figsize=(10, 6))
sns.heatmap(pivot_table, annot=True, fmt='.3f', 
           xticklabels=np.unique(max_depth),
           yticklabels=np.unique(n_estimators))
plt.xlabel('max_depth')
plt.ylabel('n_estimators')
plt.title('Средняя точность при разных комбинациях параметров')
plt.show()

# Этап 1: "Разведка" с грубой сеткой
param_grid_coarse = {
    'n_estimators': [50, 200, 500],
    'max_depth': [5, 15, None],
    'min_samples_split': [2, 10]
}
 
# Поиск с грубой сеткой
grid_search_coarse = GridSearchCV(
    estimator=model, param_grid=param_grid_coarse, cv=3, n_jobs=-1
)
grid_search_coarse.fit(X_train, y_train)
 
# Определяем лучшие параметры
best_params = grid_search_coarse.best_params_
 
# Этап 2: Уточняющий поиск вокруг найденного оптимума
n_est_best = best_params['n_estimators']
max_depth_best = best_params['max_depth']
 
param_grid_fine = {
    'n_estimators': [max(50, n_est_best - 100), n_est_best, min(1000, n_est_best + 100)],
    'max_depth': [
        max(3, max_depth_best - 3) if max_depth_best is not None else 15,
        max_depth_best,
        min(30, max_depth_best + 3) if max_depth_best is not None else None
    ],
    'min_samples_split': [2, best_params['min_samples_split'], 
                        best_params['min_samples_split'] + 5]
}
 
# Уточняющий поиск
grid_search_fine = GridSearchCV(
    estimator=model, param_grid=param_grid_fine, cv=5, n_jobs=-1
)
grid_search_fine.fit(X_train, y_train)

import pandas as pd
from sklearn.model_selection import train_test_split
 
# Создаем уменьшенную выборку для предварительного поиска
X_sample, _, y_sample, _ = train_test_split(
    X_train, y_train, train_size=0.3, random_state=42
)
 
# Поиск на уменьшенной выборке
grid_search_sample = GridSearchCV(
    estimator=model, param_grid=param_grid, cv=3, n_jobs=-1
)
grid_search_sample.fit(X_sample, y_sample)
 
# Выбираем топ-3 комбинации для проверки на полном наборе
top_params = pd.DataFrame(grid_search_sample.cv_results_)[
    ['params', 'mean_test_score']
].sort_values('mean_test_score', ascending=False).head(3)['params'].tolist()
 
# Создаем сокращенную сетку из перспективных комбинаций
param_grid_refined = {param: [] for param in param_grid.keys()}
for params in top_params:
    for param, value in params.items():
        if value not in param_grid_refined[param]:
            param_grid_refined[param].append(value)
 
# Финальный поиск на полном наборе данных
grid_search_final = GridSearchCV(
    estimator=model, param_grid=param_grid_refined, cv=5, n_jobs=-1
)
grid_search_final.fit(X_train, y_train)

grid_search = GridSearchCV(
    estimator=model,
    param_grid=param_grid,
    cv=5,
    n_jobs=-1,  # Используем все ядра
    verbose=2   # Получаем подробный вывод о прогрессе
)

from dask.distributed import Client
from dask_ml.model_selection import GridSearchCV as DaskGridSearchCV
 
# Запускаем локальный Dask-кластер
client = Client()
 
# Используем GridSearchCV из dask_ml
grid_search = DaskGridSearchCV(
    estimator=model,
    param_grid=param_grid,
    cv=5
)
grid_search.fit(X_train, y_train)

param_grid = {
    'C': [0.001, 0.01, 0.1, 1, 10, 100],
    'kernel': ['linear', 'rbf', 'poly'],
    'degree': [2, 3, 4]  # Только для kernel='poly'
}

import numpy as np
 
# Создаем 10 значений, логарифмически распределенных в диапазоне от 10^-3 до 10^3
C_values = np.logspace(-3, 3, 10)
param_grid = {
    'C': C_values,
    'kernel': ['linear', 'rbf']
}

from sklearn.model_selection import RandomizedSearchCV
from sklearn.ensemble import RandomForestClassifier
import numpy as np
 
# Определяем модель
rf = RandomForestClassifier(random_state=42)
 
# Пространство поиска - обратите внимание на более широкие диапазоны
param_distributions = {
    'n_estimators': [50, 100, 200, 300, 500],
    'max_depth': [None, 10, 20, 30, 40, 50],
    'min_samples_split': [2, 5, 10, 15, 20],
    'max_features': ['sqrt', 'log2', None]
}
 
# Запускаем случайный поиск
random_search = RandomizedSearchCV(
    estimator=rf,
    param_distributions=param_distributions,
    n_iter=100,  # Количество комбинаций для оценки
    cv=5,
    random_state=42,
    n_jobs=-1
)
 
# Обучаем
random_search.fit(X_train, y_train)
 
# Получаем лучшие параметры
print(f"Лучшие параметры: {random_search.best_params_}")

from scipy.stats import uniform, randint
 
# Смешанное пространство поиска с непрерывными и дискретными распределениями
param_distributions = {
    'n_estimators': randint(50, 500),      # Равномерное целочисленное от 50 до 500
    'max_depth': [None] + list(randint(5, 50).rvs(10)),  # None или случайное из 5-50
    'min_samples_split': randint(2, 20),   # Равномерное целочисленное от 2 до 20
    'learning_rate': uniform(0.01, 0.3)    # Равномерное от 0.01 до 0.31
}

import numpy as np
from sklearn.model_selection import RandomizedSearchCV, cross_val_score
 
# Начальный широкий поиск
wide_param_distributions = {
    'n_estimators': randint(50, 1000),
    'max_depth': [None] + list(randint(5, 100).rvs(10)),
    'min_samples_split': randint(2, 30)
}
 
initial_search = RandomizedSearchCV(
    rf, wide_param_distributions, n_iter=30, cv=3, n_jobs=-1
)
initial_search.fit(X_train, y_train)
 
# Анализируем топ-5 результатов
top_params = pd.DataFrame(initial_search.cv_results_)[
    ['params', 'mean_test_score']
].sort_values('mean_test_score', ascending=False).head(5)
 
# Определяем новые, суженные диапазоны для каждого параметра
narrow_distributions = {}
for param in wide_param_distributions:
    values = [p[param] for p in top_params['params']]
    if all(isinstance(v, (int, float)) for v in values):
        min_val, max_val = min(values), max(values)
        # Расширяем диапазон на 20% в обе стороны
        range_width = max_val - min_val
        narrow_distributions[param] = uniform(
            max(min_val - 0.2 * range_width, 0),
            min(max_val + 0.2 * range_width, 1000) - max(min_val - 0.2 * range_width, 0)
        )
    else:
        # Для категориальных параметров
        narrow_distributions[param] = values
 
# Второй этап поиска в суженной области
refined_search = RandomizedSearchCV(
    rf, narrow_distributions, n_iter=50, cv=5, n_jobs=-1
)
refined_search.fit(X_train, y_train)

from skopt import BayesSearchCV
from skopt.space import Real, Integer, Categorical
 
# Определяем пространство поиска
search_space = {
    'n_estimators': Integer(50, 500),
    'max_depth': Integer(3, 50),
    'min_samples_split': Integer(2, 20),
    'min_samples_leaf': Integer(1, 10),
    'max_features': Categorical(['sqrt', 'log2', None])
}
 
# Создаем байесовский оптимизатор
bayes_search = BayesSearchCV(
    rf,
    search_space,
    n_iter=50,  # количество итераций
    cv=5,
    n_jobs=-1,
    verbose=0
)
 
# Запускаем поиск
bayes_search.fit(X_train, y_train)
 
# Лучшие параметры
print(f"Лучшие параметры: {bayes_search.best_params_}")

import matplotlib.pyplot as plt
from sklearn.model_selection import validation_curve
 
# Строим график зависимости метрики от одного гиперпараметра
n_estimators_range = [50, 100, 200, 300, 400, 500]
train_scores, test_scores = validation_curve(
    RandomForestClassifier(),
    X_train, y_train,
    param_name="n_estimators",
    param_range=n_estimators_range,
    cv=5,
    scoring="accuracy",
    n_jobs=-1
)
 
plt.figure(figsize=(10, 6))
plt.plot(n_estimators_range, np.mean(train_scores, axis=1), 'o-', label='Training score')
plt.plot(n_estimators_range, np.mean(test_scores, axis=1), 'o-', label='Validation score')
plt.xlabel('n_estimators')
plt.ylabel('Accuracy')
plt.legend()
plt.title('Validation Curve')
plt.show()

# Пример эффективной стратегии для SVM с RBF ядром
from sklearn.svm import SVC
from sklearn.model_selection import GridSearchCV
import numpy as np
 
# Модель SVM
svm = SVC(kernel='rbf')
 
# Логарифмическая сетка для C и gamma
param_grid = {
    'C': np.logspace(-3, 3, 7),          # 0.001, 0.01, 0.1, 1, 10, 100, 1000
    'gamma': np.logspace(-4, 0, 5)       # 0.0001, 0.001, 0.01, 0.1, 1
}
 
# Grid Search с логарифмической шкалой
grid_search = GridSearchCV(
    estimator=svm,
    param_grid=param_grid,
    cv=5,
    n_jobs=-1
)

from sklearn.model_selection import RandomizedSearchCV
from sklearn.ensemble import GradientBoostingClassifier
 
# Начальный широкий поиск
wide_param_dist = {
    'n_estimators': [100, 200, 500, 1000],
    'max_depth': [3, 5, 7, 9],
    'learning_rate': [0.01, 0.05, 0.1, 0.2]
}
 
# Первая итерация - широкий поиск с малым числом фолдов
first_search = RandomizedSearchCV(
    GradientBoostingClassifier(),
    wide_param_dist,
    n_iter=20,  # Ограниченное число итераций
    cv=3,       # Меньше фолдов для ускорения
    n_jobs=-1
)
 
# После выполнения first_search.fit() анализируем лучшие комбинации
# и сужаем область поиска для более детального исследования

from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split, GridSearchCV, RandomizedSearchCV
from sklearn.svm import SVC
from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
import numpy as np
 
# Загружаем датасет
wine = load_wine()
X, y = wine.data, wine.target
 
# Разделяем на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Создаём конвейер для SVM с масштабированием
svm_pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('svm', SVC(random_state=42))
])
 
# Параметры для Grid Search
svm_param_grid = {
    'svm__C': [0.1, 1, 10, 100],
    'svm__gamma': [0.001, 0.01, 0.1, 1],
    'svm__kernel': ['rbf', 'linear']
}

# Grid Search для SVM
grid_svm = GridSearchCV(svm_pipeline, svm_param_grid, cv=5, n_jobs=-1)
grid_svm.fit(X_train, y_train)
print(f"Лучшие параметры SVM: {grid_svm.best_params_}")
print(f"Лучший результат: {grid_svm.best_score_:.4f}")

# Определяем Random Forest
rf = RandomForestClassifier(random_state=42)
 
# Пространство поиска для Random Search
rf_param_dist = {
    'n_estimators': randint(50, 200),
    'max_depth': [None] + list(range(5, 30, 5)),
    'min_samples_split': randint(2, 20),
    'min_samples_leaf': randint(1, 10),
    'max_features': ['sqrt', 'log2', None]
}
 
# Random Search для Random Forest
random_rf = RandomizedSearchCV(
    rf, rf_param_dist,
    n_iter=30,  # 30 случайных комбинаций
    cv=5,
    n_jobs=-1,
    random_state=42
)
random_rf.fit(X_train, y_train)
print(f"Лучшие параметры RF: {random_rf.best_params_}")
print(f"Лучший результат: {random_rf.best_score_:.4f}")

import time
import matplotlib.pyplot as plt
 
# Функция для отслеживания времени/производительности
def track_performance(estimator, param_grid, method='grid', n_iter=50):
    results = []
    if method == 'grid':
        search = GridSearchCV(estimator, param_grid, cv=5, n_jobs=-1)
    else:
        search = RandomizedSearchCV(estimator, param_grid, n_iter=n_iter, cv=5, n_jobs=-1)
    
    start_time = time.time()
    search.fit(X_train, y_train)
    total_time = time.time() - start_time
    
    for i, params in enumerate(search.cv_results_['params']):
        score = search.cv_results_['mean_test_score'][i]
        results.append((i+1, score, total_time * (i+1) / len(search.cv_results_['params'])))
    
    return results, search.best_score_
 
# Применяем к обоим методам
grid_results, grid_best = track_performance(svm_pipeline, svm_param_grid, 'grid')
random_results, random_best = track_performance(rf, rf_param_dist, 'random', n_iter=30)

# Строим график "оценка vs итерация"
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
plt.plot([r[0] for r in grid_results], [r[1] for r in grid_results], 'b-', label='Grid - SVM')
plt.plot([r[0] for r in random_results], [r[1] for r in random_results], 'r-', label='Random - RF')
plt.xlabel('Итерация')
plt.ylabel('Score')
plt.legend()
plt.title('Производительность по итерациям')
 
# График "оценка vs время"
plt.subplot(1, 2, 2)
plt.plot([r[2] for r in grid_results], [r[1] for r in grid_results], 'b-', label='Grid - SVM')
plt.plot([r[2] for r in random_results], [r[1] for r in random_results], 'r-', label='Random - RF')
plt.xlabel('Время (секунды)')
plt.ylabel('Score')
plt.legend()
plt.title('Производительность по времени')
plt.tight_layout()
plt.show()

from sklearn.metrics import classification_report
 
# Оцениваем лучшие модели на тестовых данных
best_svm = grid_svm.best_estimator_
best_rf = random_rf.best_estimator_
 
# Сводная таблица результатов
print("Результаты SVM:")
print(classification_report(y_test, best_svm.predict(X_test)))
 
print("\nРезультаты Random Forest:")
print(classification_report(y_test, best_rf.predict(X_test)))

from sklearn.model_selection import KFold, StratifiedKFold, TimeSeriesSplit
 
# Стандартная K-блочная кросс-валидация
kfold = KFold(n_splits=5, shuffle=True, random_state=42)
 
# Стратифицированная кросс-валидация - сохраняет пропорции классов
stratified_kfold = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
 
# Кросс-валидация для временных рядов
timeseries_split = TimeSeriesSplit(n_splits=5)
 
# Применяем выбранную стратегию в GridSearchCV
grid_search_stratified = GridSearchCV(
    estimator=svm_pipeline,
    param_grid=svm_param_grid,
    cv=stratified_kfold,  # Используем стратифицированную валидацию
    n_jobs=-1
)

# Получение детальных результатов валидации для анализа стабильности
cv_results = grid_search_stratified.cv_results_
 
# Вычисляем стандартное отклонение для лучшей модели
best_index = grid_search_stratified.best_index_
best_std = cv_results['std_test_score'][best_index]
best_mean = cv_results['mean_test_score'][best_index]
 
print(f"Среднее значение метрики: {best_mean:.4f}")
print(f"Стандартное отклонение: {best_std:.4f}")
print(f"Коэффициент вариации: {best_std/best_mean:.4f}")

# Первый этап: базовый отбор с KFold
initial_models = [
    ('svm', svm_pipeline),
    ('rf', RandomForestClassifier(random_state=42))
]
 
best_models = {}
for name, model in initial_models:
    if name == 'svm':
        param_grid = svm_param_grid
    else:
        param_grid = rf_param_dist
    
    search = RandomizedSearchCV(
        estimator=model, 
        param_distributions=param_grid,
        n_iter=20,
        cv=KFold(n_splits=3, shuffle=True),  # Более быстрая валидация
        n_jobs=-1
    )
    search.fit(X_train, y_train)
    best_models[name] = search.best_estimator_
 
# Второй этап: детальная оценка лучших моделей
final_scores = {}
for name, model in best_models.items():
    scores = cross_val_score(
        model, 
        X_train, y_train, 
        cv=StratifiedKFold(n_splits=5, shuffle=True, random_state=42),
        scoring='accuracy'
    )
    final_scores[name] = (scores.mean(), scores.std())
    
# Выбираем лучшую модель с учетом стабильности
for name, (mean, std) in final_scores.items():
    print(f"{name}: {mean:.4f} ± {std:.4f}")

from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.feature_selection import SelectKBest, f_classif
 
# Предположим, у нас есть данные с числовыми и категориальными признаками
# и мы знаем их индексы
numeric_features = [0, 1, 2, 3, 4, 5, 6, 7, 8]  # индексы числовых колонок
categorical_features = [9, 10, 11, 12]  # индексы категориальных колонок
 
# Создаем предобработчики для разных типов данных
numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler())
])
 
categorical_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('onehot', OneHotEncoder(handle_unknown='ignore'))
])
 
# Объединяем их с помощью ColumnTransformer
preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, numeric_features),
        ('cat', categorical_transformer, categorical_features)
    ])
 
# Создаем полный пайплайн, включающий предобработку и модель
full_pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('feature_selection', SelectKBest(f_classif, k=5)),  # Выбор лучших признаков
    ('classifier', RandomForestClassifier())
])

# Параметры для поиска, включая этапы предобработки
param_grid = {
    'preprocessor__num__imputer__strategy': ['mean', 'median'],
    'feature_selection__k': [3, 5, 7, 'all'],  # 'all' - использовать все признаки
    'classifier__n_estimators': [50, 100, 200],
    'classifier__max_depth': [None, 10, 20]
}
 
# GridSearchCV найдет оптимальную комбинацию на всех уровнях
grid_search = GridSearchCV(
    full_pipeline, param_grid, cv=5, scoring='accuracy', n_jobs=-1
)
grid_search.fit(X_train, y_train)

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split, RandomizedSearchCV, StratifiedKFold
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.impute import SimpleImputer
from sklearn.feature_selection import SelectFromModel
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.metrics import classification_report
import time
 
# Функция для создания модели с прогрессивным поиском
def progressive_hyperparameter_search(X, y, test_size=0.2, random_state=42):
    # Разделение на обучающую и тестовую выборки
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=test_size, random_state=random_state
    )
    
    # 1. Этап: Быстрая предварительная оценка моделей
    models = {
        'rf': RandomForestClassifier(random_state=random_state),
        'svm': SVC(random_state=random_state)
    }
    
    # Базовый пайплайн для начальной оценки
    base_pipeline = Pipeline([
        ('imputer', SimpleImputer(strategy='median')),
        ('scaler', StandardScaler()),
        ('model', None)  # Будет заменен на конкретную модель
    ])
    
    model_scores = {}
    for name, model in models.items():
        start_time = time.time()
        pipeline = base_pipeline.set_params(model=model)
        
        # Простая кросс-валидация для быстрой оценки
        cv_score = np.mean(cross_val_score(
            pipeline, X_train, y_train, cv=3, scoring='accuracy'
        ))
        elapsed = time.time() - start_time
        
        model_scores[name] = {
            'score': cv_score,
            'time': elapsed
        }
        print(f"Базовая оценка {name}: {cv_score:.4f} (за {elapsed:.2f} сек)")
    
    # Выбираем две лучшие модели по скору
    top_models = sorted(
        model_scores.items(), 
        key=lambda x: x[1]['score'], 
        reverse=True
    )[:2]
    
    # 2. Этап: Случайный поиск для лучших моделей с расширенным пайплайном
    best_model_info = None
    best_score = 0
    
    for model_name, _ in top_models:
        print(f"\nПрогрессивный поиск для {model_name}...")
        
        # Определяем параметры поиска в зависимости от типа модели
        if model_name == 'rf':
            model = RandomForestClassifier(random_state=random_state)
            param_dist = {
                'model__n_estimators': randint(50, 300),
                'model__max_depth': [None] + list(range(5, 30, 5)),
                'model__min_samples_split': randint(2, 20),
                'feature_sel__estimator__n_estimators': [100],  # Фиксированные параметры для отбора признаков
                'imputer__strategy': ['mean', 'median']
            }
        else:  # SVM
            model = SVC(probability=True, random_state=random_state)
            param_dist = {
                'model__C': loguniform(1e-1, 1e3),
                'model__gamma': loguniform(1e-3, 1e1),
                'model__kernel': ['rbf', 'linear'],
                'feature_sel__estimator__n_estimators': [100],
                'imputer__strategy': ['mean', 'median']
            }
        
        # Создаем расширенный пайплайн с отбором признаков
        feature_selector = SelectFromModel(
            RandomForestClassifier(random_state=random_state)
        )
        
        pipeline = Pipeline([
            ('imputer', SimpleImputer()),
            ('scaler', StandardScaler()),
            ('feature_sel', feature_selector),
            ('model', model)
        ])
        
        # Случайный поиск с стратифицированной кросс-валидацией
        search = RandomizedSearchCV(
            pipeline,
            param_distributions=param_dist,
            n_iter=30,  # Количество случайных комбинаций
            cv=StratifiedKFold(n_splits=5, shuffle=True, random_state=random_state),
            scoring='accuracy',
            n_jobs=-1,
            random_state=random_state
        )
        
        search.fit(X_train, y_train)
        
        if search.best_score_ > best_score:
            best_score = search.best_score_
            best_model_info = {
                'name': model_name,
                'pipeline': search.best_estimator_,
                'params': search.best_params_,
                'score': search.best_score_
            }
    
    # 3. Этап: Финальная оценка на тестовых данных
    best_pipeline = best_model_info['pipeline']
    y_pred = best_pipeline.predict(X_test)
    
    print("\nЛучшая модель:", best_model_info['name'])
    print("Лучшие параметры:", best_model_info['params'])
    print("Валидационный скор:", best_model_info['score'])
    print("\nРезультаты на тестовой выборке:")
    print(classification_report(y_test, y_pred))
    
    return best_model_info
 
# Использование функции
from scipy.stats import randint, loguniform
from sklearn.model_selection import cross_val_score
from sklearn.datasets import load_wine
 
# Загружаем данные
wine = load_wine()
X, y = wine.data, wine.target
 
# Запускаем прогрессивный поиск
best_model = progressive_hyperparameter_search(X, y)