Настройка гиперпараметров

Гиперпараметры — это ручки, которые вы настраиваете до начала обучения. Удачная настройка отделяет посредственную модель от превосходной.

Тип: Сборка Язык: Python Предварительные требования: Фаза 2, урок 11 (ансамблевые методы) Время: ~90 минут

Цели обучения

• Реализовать поиск по сетке, случайный поиск и байесовскую оптимизацию с нуля и сравнить эффективность их выборок
• Объяснить, почему случайный поиск превосходит поиск по сетке, когда у большинства гиперпараметров низкая эффективная размерность
• Построить цикл байесовской оптимизации с суррогатной моделью и функцией приобретения, направляющий поиск
• Спроектировать стратегию настройки гиперпараметров, которая предотвращает переобучение на валидационном наборе с помощью правильной кросс-валидации

Проблема

У вашей модели градиентного бустинга есть скорость обучения, число деревьев, максимальная глубина, минимальное число образцов в листе, коэффициент подвыборки и коэффициент выборки столбцов. Это шесть гиперпараметров. Если для каждого есть 5 разумных значений, сетка содержит 5^6 = 15 625 комбинаций. Обучение каждой занимает 10 секунд. Чтобы попробовать их все, потребуется 43 часа вычислений.

Поиск по сетке — очевидный подход и худший при большом масштабе. Случайный поиск даёт лучшие результаты при меньших вычислениях. Байесовская оптимизация идёт ещё дальше, обучаясь на прошлых оценках. Знание, какую стратегию применять и какие гиперпараметры действительно важны, экономит дни впустую потраченного GPU-времени.

Концепция

Параметры и гиперпараметры

Параметры изучаются во время обучения (веса, смещения, пороги разбиений). Гиперпараметры задаются до начала обучения и управляют тем, как оно происходит.

Гиперпараметр	Чем управляет	Типичный диапазон
Скорость обучения	Размер шага при каждом обновлении	От 0.001 до 1.0
Число деревьев/эпох	Как долго обучаться	От 10 до 10 000
Максимальная глубина	Сложность модели	От 1 до 30
Регуляризация (lambda)	Предотвращение переобучения	От 0.0001 до 100
Размер батча	Шум оценки градиента	От 16 до 512
Доля dropout	Доля отключаемых нейронов	От 0.0 до 0.5

Поиск по сетке

Поиск по сетке оценивает каждую комбинацию заданных значений. Он исчерпывающий и понятный, но масштабируется экспоненциально с числом гиперпараметров.

Grid for 2 hyperparameters:

  learning_rate: [0.01, 0.1, 1.0]
  max_depth:     [3, 5, 7]

  Evaluations: 3 x 3 = 9 combinations

  (0.01, 3)  (0.01, 5)  (0.01, 7)
  (0.1,  3)  (0.1,  5)  (0.1,  7)
  (1.0,  3)  (1.0,  5)  (1.0,  7)

У поиска по сетке есть фундаментальный изъян: если один гиперпараметр важен, а другой нет, большинство оценок тратится впустую. Из 9 оценок вы получаете лишь 3 уникальных значения важного параметра.

Случайный поиск

Случайный поиск берёт выборки гиперпараметров из распределений, а не из сетки. При том же бюджете в 9 оценок вы получаете по 9 уникальных значений каждого гиперпараметра.

Почему случайный поиск лучше сетки (Bergstra & Bengio, 2012):

• У большинства гиперпараметров низкая эффективная размерность. Для данной задачи обычно имеют значение лишь 1–2 из 6 гиперпараметров.
• Поиск по сетке тратит оценки на неважные измерения.
• При том же бюджете случайный поиск плотнее покрывает важные измерения.
• При 60 случайных испытаниях у вас 95% шанс найти точку в пределах 5% от оптимума (если он существует в пространстве поиска).

Байесовская оптимизация

Случайный поиск игнорирует результаты. Он не узнаёт, что высокие скорости обучения вызывают расходимость или что глубина 3 стабильно превосходит глубину 10. Байесовская оптимизация использует прошлые оценки, чтобы решить, где искать дальше.

Два ключевых компонента:

Суррогатная модель: дешёвая для вычисления модель (обычно гауссовский процесс), которая приближает дорогую целевую функцию. В любой точке пространства поиска она даёт и предсказание, и оценку неопределённости.

Функция приобретения: решает, где вычислять следующую оценку, балансируя эксплуатацию (искать около известных хороших точек) и исследование (искать там, где неопределённость высока). Распространённые варианты:

• Ожидаемое улучшение (EI): какого улучшения относительно текущего лучшего результата мы ожидаем в этой точке?
• Верхняя доверительная граница (UCB): предсказание плюс множитель неопределённости. Высокий UCB означает либо перспективность, либо неисследованность.
• Вероятность улучшения (PI): какова вероятность, что эта точка превзойдёт текущую лучшую?

Байесовская оптимизация обычно находит лучшие гиперпараметры, чем случайный поиск, с в 2–5 раз меньшим числом оценок. Накладные расходы на подгонку суррогатной модели пренебрежимо малы по сравнению с обучением настоящей модели.

Ранняя остановка

Не каждый запуск обучения должен завершаться. Если конфигурация явно плоха после 10 эпох, остановите её и переходите дальше. В контексте поиска гиперпараметров это ранняя остановка.

Стратегии:

• По терпению: остановиться, если валидационная потеря не улучшалась N последовательных эпох
• Отсечение по медиане: остановиться, если промежуточный результат испытания хуже медианы завершённых испытаний на том же шаге
• Hyperband: выделить небольшие бюджеты множеству конфигураций, затем постепенно увеличивать бюджет лучших

Hyperband особенно эффективен. Он начинает с 81 конфигурации по 1 эпохе, сохраняет верхнюю треть, даёт им 3 эпохи, снова сохраняет верхнюю треть и так далее. Это находит хорошие конфигурации в 10–50 раз быстрее, чем полное оценивание всех конфигураций.

Планировщики скорости обучения

Скорость обучения почти всегда является самым важным гиперпараметром. Вместо сохранения её постоянной планировщики корректируют её во время обучения.

Планировщик	Формула	Когда использовать
Ступенчатое затухание	Умножать на 0.1 каждые N эпох	Классическое обучение CNN
Косинусный отжиг	lr * 0.5 * (1 + cos(pi * t / T))	Современный вариант по умолчанию
Разогрев + затухание	Линейный рост, затем косинусное затухание	Трансформеры
Один цикл	Рост, затем снижение за один цикл	Быстрая сходимость
Снижение на плато	Снизить на множитель при стагнации метрики	Безопасный вариант по умолчанию

Важность гиперпараметров

Не все гиперпараметры одинаково важны. Исследования случайных лесов (Probst et al., 2019) и градиентного бустинга показывают устойчивые закономерности:

Высокая важность:

• Скорость обучения (всегда настраивайте первой)
• Число оценщиков / эпох (используйте раннюю остановку вместо настройки)
• Сила регуляризации

Средняя важность:

• Максимальная глубина / число слоёв
• Минимальное число образцов в листе / weight decay
• Коэффициент подвыборки

Низкая важность:

• Максимум признаков (для случайных лесов)
• Конкретный выбор функции активации
• Размер батча (в разумном диапазоне)

Сначала настраивайте важные параметры, остальные оставляйте со значениями по умолчанию.

Практическая стратегия

Конкретный рабочий процесс:

1. Начните со значений по умолчанию библиотеки. Их выбирали опытные практики, и часто они уже на 80% приводят к цели.
2. Грубый случайный поиск. Широкие диапазоны, 20–50 испытаний. Используйте раннюю остановку, чтобы быстро прекращать плохие запуски.
3. Проанализируйте результаты. Какие гиперпараметры коррелируют с качеством? Сузьте пространство поиска.
4. Тонкий поиск. Байесовская оптимизация или сфокусированный случайный поиск в суженном пространстве. 50–100 испытаний.
5. Переобучите модель на всех обучающих данных с найденными лучшими гиперпараметрами.

Интеграция с кросс-валидацией

Настраивать гиперпараметры на одном валидационном разбиении рискованно. Лучшие гиперпараметры могут переобучиться к конкретному валидационному фолду. Вложенная кросс-валидация решает это двумя циклами:

• Внешний цикл (оценивание): делит данные на train+val и test. Сообщает несмещённое качество.
• Внутренний цикл (настройка): делит train+val на train и val. Находит лучшие гиперпараметры.

Каждый внешний фолд независимо находит собственные лучшие гиперпараметры. Внешние оценки — несмещённая оценка качества обобщения.

Со sklearn:

from sklearn.model_selection import cross_val_score, GridSearchCV
from sklearn.ensemble import GradientBoostingRegressor

inner_cv = GridSearchCV(
    GradientBoostingRegressor(),
    param_grid={
        "learning_rate": [0.01, 0.05, 0.1],
        "max_depth": [2, 3, 5],
        "n_estimators": [50, 100, 200],
    },
    cv=5,
    scoring="neg_mean_squared_error",
)

outer_scores = cross_val_score(
    inner_cv, X, y, cv=5, scoring="neg_mean_squared_error"
)

print(f"Nested CV MSE: {-outer_scores.mean():.4f} +/- {outer_scores.std():.4f}")

Это дорого (5 внешних фолдов x 5 внутренних фолдов x 27 точек сетки = 675 подгонок модели), но даёт заслуживающую доверия оценку качества. Используйте её, сообщая финальные результаты в статьях или когда решение имеет высокую цену.

Практические советы

Начните со скорости обучения. Она всегда важнее всего для методов на основе градиента. Плохая скорость обучения делает всё остальное несущественным. Зафиксируйте другие гиперпараметры на значениях по умолчанию и сначала перебирайте скорость обучения.

Используйте логарифмически равномерные распределения для скорости обучения и регуляризации. Разница между 0.001 и 0.01 так же важна, как между 0.1 и 1.0. Линейный поиск тратит бюджет на большом конце диапазона.

Используйте раннюю остановку вместо настройки n_estimators. Для бустинга и нейронных сетей задайте большим n_estimators или число эпох и позвольте ранней остановке решить, когда завершить обучение. Так вы удаляете один гиперпараметр из поиска.

Распределение бюджета. Потратьте 60% бюджета настройки на два важнейших гиперпараметра. Оставшиеся 40% потратьте на всё остальное. Два главных параметра отвечают за большую часть вариации качества.

Масштаб важен. Никогда не ищите размер батча в логарифмическом масштабе (16, 32, 64 вполне подходят). Всегда ищите скорость обучения в логарифмическом масштабе. Согласуйте распределение поиска с тем, как гиперпараметр влияет на модель.

Тип модели	Главные гиперпараметры	Рекомендуемый поиск	Бюджет
Случайный лес	n_estimators, max_depth, min_samples_leaf	Случайный поиск, 50 испытаний	Низкий (быстрое обучение)
Градиентный бустинг	learning_rate, n_estimators, max_depth	Байесовский, 100 испытаний + ранняя остановка	Средний
Нейронная сеть	learning_rate, weight_decay, batch_size	Байесовский или случайный, 100+ испытаний	Высокий (медленное обучение)
SVM	C, gamma (RBF-ядро)	Сетка в логарифмическом масштабе, 25–50 испытаний	Низкий (2 параметра)
Lasso/Ridge	alpha	Одномерный поиск в логарифмическом масштабе, 20 испытаний	Очень низкий
XGBoost	learning_rate, max_depth, subsample, colsample	Байесовский, 100–200 испытаний + ранняя остановка	Средний

Если сомневаетесь: выполняйте случайный поиск с числом испытаний, вдвое большим числа гиперпараметров (например, 6 гиперпараметров = минимум 12+ испытаний). Вы удивитесь, как часто случайный поиск с 50 испытаниями превосходит тщательно спроектированный поиск по сетке.

k-fold-cv

Соберите это

Код в code/tuning.py реализует поиск по сетке, случайный поиск и простой байесовский оптимизатор с нуля.

Шаг 1: поиск по сетке с нуля

def grid_search(model_fn, param_grid, X_train, y_train, X_val, y_val):
    keys = list(param_grid.keys())
    values = list(param_grid.values())
    best_score = -float("inf")
    best_params = None
    n_evals = 0

    for combo in itertools.product(*values):
        params = dict(zip(keys, combo))
        model = model_fn(**params)
        model.fit(X_train, y_train)
        score = evaluate(model, X_val, y_val)
        n_evals += 1

        if score > best_score:
            best_score = score
            best_params = params

    return best_params, best_score, n_evals

Шаг 2: случайный поиск с нуля

def random_search(model_fn, param_distributions, X_train, y_train,
                  X_val, y_val, n_iter=50, seed=42):
    rng = np.random.RandomState(seed)
    best_score = -float("inf")
    best_params = None

    for _ in range(n_iter):
        params = {k: sample(v, rng) for k, v in param_distributions.items()}
        model = model_fn(**params)
        model.fit(X_train, y_train)
        score = evaluate(model, X_val, y_val)

        if score > best_score:
            best_score = score
            best_params = params

    return best_params, best_score, n_iter

Шаг 3: байесовская оптимизация (упрощённая)

Основная идея: подогнать гауссовский процесс к наблюдаемым парам (гиперпараметр, оценка), затем использовать функцию приобретения, чтобы решить, куда смотреть дальше.

class SimpleBayesianOptimizer:
    def __init__(self, search_space, n_initial=5):
        self.search_space = search_space
        self.n_initial = n_initial
        self.X_observed = []
        self.y_observed = []

    def _kernel(self, x1, x2, length_scale=1.0):
        dists = np.sum((x1[:, None, :] - x2[None, :, :]) ** 2, axis=2)
        return np.exp(-0.5 * dists / length_scale ** 2)

    def _fit_gp(self, X_new):
        X_obs = np.array(self.X_observed)
        y_obs = np.array(self.y_observed)
        y_mean = y_obs.mean()
        y_centered = y_obs - y_mean

        K = self._kernel(X_obs, X_obs) + 1e-4 * np.eye(len(X_obs))
        K_star = self._kernel(X_new, X_obs)

        L = np.linalg.cholesky(K)
        alpha = np.linalg.solve(L.T, np.linalg.solve(L, y_centered))
        mu = K_star @ alpha + y_mean

        v = np.linalg.solve(L, K_star.T)
        var = 1.0 - np.sum(v ** 2, axis=0)
        var = np.maximum(var, 1e-6)

        return mu, var

    def _expected_improvement(self, mu, var, best_y):
        sigma = np.sqrt(var)
        z = (mu - best_y) / (sigma + 1e-10)
        ei = sigma * (z * norm_cdf(z) + norm_pdf(z))
        return ei

    def suggest(self):
        if len(self.X_observed) < self.n_initial:
            return sample_random(self.search_space)

        candidates = [sample_random(self.search_space) for _ in range(500)]
        X_cand = np.array([to_vector(c) for c in candidates])
        mu, var = self._fit_gp(X_cand)
        ei = self._expected_improvement(mu, var, max(self.y_observed))
        return candidates[np.argmax(ei)]

    def observe(self, params, score):
        self.X_observed.append(to_vector(params))
        self.y_observed.append(score)

Суррогат на основе гауссовского процесса даёт в каждой точке-кандидате два значения: предсказанную оценку (mu) и неопределённость (var). Ожидаемое улучшение балансирует их: оно предпочитает точки, где модель предсказывает высокие оценки ИЛИ высокая неопределённость. Вначале у большинства точек неопределённость высока, поэтому оптимизатор исследует пространство. Позже он сосредотачивается на наиболее перспективной области.

Шаг 4: сравните все методы

Запустите все три метода на одной синтетической целевой функции и сравните. Это сравнение использует упрощённую оболочку, вызывающую каждый оптимизатор с прямой целевой функцией (без обучения модели), поэтому API отличается от реализаций на основе модели выше:

def synthetic_objective(params):
    lr = params["learning_rate"]
    depth = params["max_depth"]
    return -(np.log10(lr) + 2) ** 2 - (depth - 4) ** 2 + 10

param_grid = {
    "learning_rate": [0.001, 0.01, 0.1, 1.0],
    "max_depth": [2, 3, 4, 5, 6, 7, 8],
}

grid_best = None
grid_score = -float("inf")
grid_history = []
for combo in itertools.product(*param_grid.values()):
    params = dict(zip(param_grid.keys(), combo))
    score = synthetic_objective(params)
    grid_history.append((params, score))
    if score > grid_score:
        grid_score = score
        grid_best = params

param_dist = {
    "learning_rate": ("log_float", 0.001, 1.0),
    "max_depth": ("int", 2, 8),
}

rand_best = None
rand_score = -float("inf")
rand_history = []
rng = np.random.RandomState(42)
for _ in range(28):
    params = {k: sample(v, rng) for k, v in param_dist.items()}
    score = synthetic_objective(params)
    rand_history.append((params, score))
    if score > rand_score:
        rand_score = score
        rand_best = params

optimizer = SimpleBayesianOptimizer(param_dist, n_initial=5)
bayes_history = []
for _ in range(28):
    params = optimizer.suggest()
    score = synthetic_objective(params)
    optimizer.observe(params, score)
    bayes_history.append((params, score))
bayes_score = max(s for _, s in bayes_history)

print(f"{'Method':<20} {'Best Score':>12} {'Evaluations':>12}")
print("-" * 50)
print(f"{'Grid Search':<20} {grid_score:>12.4f} {len(grid_history):>12}")
print(f"{'Random Search':<20} {rand_score:>12.4f} {len(rand_history):>12}")
print(f"{'Bayesian Opt':<20} {bayes_score:>12.4f} {len(bayes_history):>12}")

При одинаковом бюджете байесовская оптимизация обычно быстрее всего находит лучшую оценку, поскольку не тратит оценки в явно плохих областях. Случайный поиск покрывает больше пространства, чем поиск по сетке. Поиск по сетке выигрывает лишь при очень малом числе гиперпараметров, когда можно позволить себе исчерпывающий перебор.

Используйте это

Optuna на практике

Optuna — рекомендуемая библиотека для серьёзной настройки гиперпараметров. Она из коробки поддерживает отсечение, распределённый поиск и визуализацию.

import optuna

def objective(trial):
    lr = trial.suggest_float("learning_rate", 1e-4, 1e-1, log=True)
    n_est = trial.suggest_int("n_estimators", 50, 500)
    max_depth = trial.suggest_int("max_depth", 2, 10)

    model = GradientBoostingRegressor(
        learning_rate=lr,
        n_estimators=n_est,
        max_depth=max_depth,
    )
    model.fit(X_train, y_train)
    return mean_squared_error(y_val, model.predict(X_val))

study = optuna.create_study(direction="minimize")
study.optimize(objective, n_trials=100)

print(f"Best params: {study.best_params}")
print(f"Best MSE: {study.best_value:.4f}")

Ключевые возможности Optuna:

• suggest_float(..., log=True) для параметров, которые лучше искать в логарифмическом масштабе (скорость обучения, регуляризация)
• suggest_int для целочисленных параметров
• suggest_categorical для дискретных выборов
• Встроенный MedianPruner для ранней остановки плохих испытаний
• study.trials_dataframe() для анализа

Optuna с отсечением

Отсечение рано останавливает неперспективные испытания, экономя огромные вычисления. Вот шаблон:

import optuna
from sklearn.model_selection import cross_val_score

def objective(trial):
    params = {
        "learning_rate": trial.suggest_float("lr", 1e-4, 0.5, log=True),
        "max_depth": trial.suggest_int("max_depth", 2, 10),
        "n_estimators": trial.suggest_int("n_estimators", 50, 500),
        "subsample": trial.suggest_float("subsample", 0.5, 1.0),
    }

    model = GradientBoostingRegressor(**params)
    scores = cross_val_score(model, X_train, y_train, cv=3,
                             scoring="neg_mean_squared_error")
    mean_score = -scores.mean()

    trial.report(mean_score, step=0)
    if trial.should_prune():
        raise optuna.TrialPruned()

    return mean_score

pruner = optuna.pruners.MedianPruner(n_startup_trials=10, n_warmup_steps=5)
study = optuna.create_study(direction="minimize", pruner=pruner)
study.optimize(objective, n_trials=200)

MedianPruner останавливает испытание, если его промежуточное значение хуже медианы всех завершённых испытаний на том же шаге. Для отсечения требуются вызовы trial.report() для передачи промежуточных метрик и trial.should_prune() для проверки, следует ли остановить испытание. n_startup_trials=10 гарантирует, что до начала отсечения полностью завершатся хотя бы 10 испытаний. Обычно это экономит 40–60% всех вычислений.

Встроенные настройщики sklearn

Для быстрых экспериментов sklearn предоставляет GridSearchCV, RandomizedSearchCV и HalvingRandomSearchCV:

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

param_dist = {
    "learning_rate": loguniform(1e-4, 0.5),
    "max_depth": randint(2, 10),
    "n_estimators": randint(50, 500),
}

search = RandomizedSearchCV(
    GradientBoostingRegressor(),
    param_dist,
    n_iter=100,
    cv=5,
    scoring="neg_mean_squared_error",
    random_state=42,
    n_jobs=-1,
)
search.fit(X_train, y_train)
print(f"Best params: {search.best_params_}")
print(f"Best CV MSE: {-search.best_score_:.4f}")

Используйте loguniform из scipy для скорости обучения и регуляризации. Используйте randint для целочисленных гиперпараметров. Флаг n_jobs=-1 распараллеливает работу на все ядра CPU.

Распространённые ошибки в настройке гиперпараметров

Утечка данных через предобработку. Если подогнать масштабировщик на всём наборе данных до кросс-валидации, информация из валидационного фолда попадёт в обучение. Всегда помещайте предобработку внутрь Pipeline, чтобы она подгонялась только на обучающем фолде.

Переобучение на валидационном наборе. Тысячи испытаний фактически обучают модель на валидационном наборе. Для финальной оценки качества используйте вложенную кросс-валидацию либо отложите отдельный тестовый набор, который никогда не затрагиваете при настройке.

Слишком узкий диапазон поиска. Если лучшее значение находится на границе пространства поиска, вы искали недостаточно широко. Оптимальное значение может быть за пределами диапазона. Всегда проверяйте, не находятся ли лучшие параметры на краях.

Игнорирование эффектов взаимодействия. Скорость обучения и число оценщиков сильно взаимодействуют в бустинге. Низкой скорости обучения нужно больше оценщиков. Независимая настройка даёт худший результат, чем совместная.

Неиспользование ранней остановки для итеративных моделей. Для градиентного бустинга и нейронных сетей задайте большим n_estimators или число эпох и используйте раннюю остановку. Это строго лучше, чем настраивать число итераций как гиперпараметр.

Упражнения

1. Запустите поиск по сетке и случайный поиск с одинаковым общим бюджетом (например, 50 оценок). Сравните найденные лучшие оценки. Повторите эксперимент 10 раз с разными seed. Как часто побеждает случайный поиск?

2. Реализуйте Hyperband с нуля. Начните с 81 конфигурации, каждая обучается 1 эпоху. На каждом раунде сохраняйте верхнюю 1/3 и утраивайте их бюджет. Сравните суммарные вычисления (сумму всех эпох по всем конфигурациям) с запуском 81 конфигурации на полный бюджет.

3. Добавьте планировщик скорости обучения (косинусный отжиг) к реализации градиентного бустинга из урока 11. Помогает ли он по сравнению с фиксированной скоростью обучения?

4. Используйте Optuna для настройки RandomForestClassifier на реальном наборе данных (например, наборе breast cancer из sklearn). Используйте optuna.visualization.plot_param_importances(study), чтобы увидеть, какие гиперпараметры наиболее важны. Совпадает ли это с рейтингом важности из урока?

5. Реализуйте простую функцию приобретения (ожидаемое улучшение) и покажите исследование против эксплуатации. Постройте среднее и неопределённость суррогатной модели и покажите, где EI выбирает следующую точку для вычисления.

Ключевые термины

Термин	Как обычно говорят	Что это действительно означает
Гиперпараметр	«Настройка, которую вы выбираете»	Значение, задаваемое до обучения и управляющее процессом обучения; оно не изучается из данных.
Поиск по сетке	«Попробовать каждую комбинацию»	Исчерпывающий поиск по заданной сетке параметров. Экспоненциальная стоимость.
Случайный поиск	«Просто брать случайные выборки»	Выбирать гиперпараметры из распределений. Лучше покрывает важные измерения, чем поиск по сетке.
Байесовская оптимизация	«Умный поиск»	Использует суррогатную модель цели, чтобы решить, где оценивать дальше, балансируя исследование и эксплуатацию.
Суррогатная модель	«Дешёвое приближение»	Модель (обычно гауссовский процесс), приближающая дорогую целевую функцию по наблюдённым оценкам.
Функция приобретения	«Где смотреть дальше»	Оценивает точки-кандидаты, балансируя ожидаемое улучшение и неопределённость. EI и UCB — распространённые варианты.
Ранняя остановка	«Перестать терять время»	Рано завершать обучение, когда валидационное качество перестаёт улучшаться.
Hyperband	«Турнирная сетка для конфигураций»	Адаптивное выделение ресурсов: начать с многих конфигураций и малыми бюджетами, сохранять лучшие и увеличивать их бюджеты.
Планировщик скорости обучения	«Менять lr во время обучения»	Функция, корректирующая скорость обучения в ходе обучения для лучшей сходимости.

Дополнительное чтение

• Bergstra & Bengio: Random Search for Hyper-Parameter Optimization (2012) — статья, показавшая, что случайный поиск превосходит поиск по сетке
• Snoek et al., Practical Bayesian Optimization of Machine Learning Algorithms (2012) — байесовская оптимизация для ML
• Li et al., Hyperband: A Novel Bandit-Based Approach (2018) — статья о Hyperband
• Optuna: A Next-generation Hyperparameter Optimization Framework — статья об Optuna
• Probst et al., Tunability: Importance of Hyperparameters (2019) — какие гиперпараметры важны

---

Источник: Hyperparameter Tuning 02.11 — Ансамблевые методы · Фаза 2 — Основы машинного обучения · Полный каталог · 02.13 — Конвейеры машинного обучения