3.2. Настройка гиперпараметров модели

Гиперпараметры - это параметры, которые не обучаются непосредственно в модели. В scikit-learn они передаются в качестве аргументов в конструктор классов моделей. Типичные примеры: C, kernel и gamma для Support Vector Classifier, alpha для Lasso и т.д.

Можно и рекомендуется искать в пространстве гиперпараметров наилучшую оценку c помощью кросс-валидации.

Любой параметр, задаваемый при построении модели, может быть оптимизирован таким образом. В частности, чтобы найти имена и текущие значения всех параметров для данной модели, используйте:

estimator.get_params()

Поиск состоит из:

• модели (регрессора или классификатора, такого как sklearn.svm.SVC());

• пространства параметров;

• метод поиска или выборки кандидатов;

• схема кросс-валидации; и

• функция score.

В scikit-learn предусмотрено два общих подхода к поиску параметров: для заданных значений GridSearchCV исчерпывающе рассматривает все комбинации параметров, а RandomizedSearchCV может выбрать заданное количество кандидатов из пространства параметров с заданным распределением. Оба этих инструмента имеют последовательные аналоги HalvingGridSearchCV и HalvingRandomSearchCV, которые могут быть гораздо быстрее в поиске хорошей комбинации параметров.

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

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

3.2.1. Исчерпывающий поиск по сетке (Grid Search)

Поиск по сетке, предоставляемый GridSearchCV, исчерпывающе генерирует кандидатов из сетки значений параметров, заданных параметром param_grid. Например, следующее значение param_grid:

param_grid = [
  {'C': [1, 10, 100, 1000], 'kernel': ['linear']},
  {'C': [1, 10, 100, 1000], 'gamma': [0.001, 0.0001], 'kernel': ['rbf']},
 ]

указывает, что должны быть исследованы две сетки: одна с линейным ядром и значениями C в [1, 10, 100, 1000], а вторая - с RBF-ядром и другая со значеними C в диапазоне [1, 10, 100, 1000] и гаммы в [0.001, 0.0001].

Экземпляр GridSearchCV реализует обычный API модели: при его “обучении” к набору данных оцениваются все возможные комбинации значений параметров и сохраняется наилучшая комбинация.

Примеры:

• См. Custom refit strategy of a grid search with cross-validation для примера вычислений поиска по сетке в наборе данных цифр.

• См. Sample pipeline for text feature extraction and evaluation пример соединения параметров Grid Search из экстрактора признаков текстовых документов (векторизатора количества n-грамм и трансформатора TF-IDF) с классификатором (здесь линейный SVM, обученный с помощью SGD с эластичной сетью или L2-штрафом) с помощью экземпляра Pipeline.

• См. Nested versus non-nested cross-validation пример использования поиска по сетке в цикле кросс-валидации на наборе данных Ирис. Это лучшая практика для оценки производительности модели с поиском по сетке.

• См. Demonstration of multi-metric evaluation on cross_val_score and GridSearchCV для примера GridSearchCV используется для оценки нескольких показателей одновременно.

• См. Balance model complexity and cross-validated score пример использования интерфейса refit=callable в GridSearchCV`. Пример показывает, как этот интерфейс добавляет определенную гибкость в определении “лучшей” модели. Этот интерфейс также может быть использован при оценке по нескольким метрикам.

• См. Statistical comparison of models using grid search для примера того, как провести статистическое сравнение результатов GridSearchCV.

3.2.2. Рандомизированная оптимизация параметров

Хотя использование сетки параметров в настоящее время является наиболее распространенным методом оптимизации параметров, другие методы поиска обладают более благоприятными свойствами.

RandomizedSearchCV реализует рандомизированный поиск по параметрам, где каждая настройка выбирается из распределения возможных значений параметров. Это имеет два основных преимущества перед исчерпывающим поиском:

• Количество вычислений может быть выбран независимо от количества параметров и возможных значений.

• Добавление параметров, не влияет на производительность и не снижает эффективность.

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

Для каждого параметра можно указать либо распределение по возможным значениям, либо список дискретных вариантов (которые будут выбраны равномерно):

{'C': scipy.stats.expon(scale=100), 'gamma': scipy.stats.expon(scale=.1),
  'kernel': ['rbf'], 'class_weight':['balanced', None]}

В этом примере используется модуль scipy.stats, который содержит множество полезных распределений для выборки параметров, таких как expon, gamma, uniform, loguniform или randint.

В принципе, можно передать любую функцию, которая предоставляет метод rvs (random variate sample - выборка случайной величины) для выборки значения. Вызов функции rvs должен обеспечивать независимые случайные выборки из возможных значений параметров при последовательных вызовах.

Предупреждение

Распределения в scipy.stats до версии scipy 0.16 не позволяют указывать случайное состояние. Вместо этого они используют глобальное случайное состояние numpy, которое можно зафиксировать с помощью np.random.seed или установить с помощью np.random.set_state. Однако, начиная с scikit-learn 0.18, модуль sklearn.model_selection устанавливает случайное состояние, предоставленное пользователем, если scipy >= 0.16 также доступен.

Для непрерывных параметров, таких как C из примера выше, важно указать непрерывное распределение, чтобы использовать все преимущества рандомизации. Таким образом, увеличение n_iter всегда будет приводить к более тонкому поиску.

Непрерывная логарифмическая случайная величина - это непрерывная версия логарифмического параметра. Например, чтобы указать эквивалент C из вышеприведенного, можно использовать loguniform(1, 100) вместо [1, 10, 100].

По аналогии с приведенным выше примером поиска по сетке, мы можем задать непрерывную случайную величину, логарифмически равномерно распределенную между 1e0 и 1e3:

from sklearn.utils.fixes import loguniform
{'C': loguniform(1e0, 1e3),
 'gamma': loguniform(1e-4, 1e-3),
 'kernel': ['rbf'],
 'class_weight':['balanced', None]}

Примеры:

• Comparing randomized search and grid search for hyperparameter estimation сравнивает использование и эффективность рандомизированного поиска и поиска по сетке.

Ссылки:

• Bergstra, J. and Bengio, Y., Random search for hyper-parameter optimization, The Journal of Machine Learning Research (2012)

3.2.3. Поиск оптимальных параметров с помощью последовательного перебора

Scikit-learn также предоставляет оценки HalvingGridSearchCV и HalvingRandomSearchCV, которые могут быть использованы для поиска пространства параметров с помощью последовательного халвинга [1] [2]. Последовательный халвинг (Successive halving - SH) похож на турнир среди комбинаций параметров-кандидатов. SH - это итерационный процесс выбора, в котором все кандидаты (комбинации параметров) оцениваются с небольшим количеством ресурсов на первой итерации. Только некоторые из этих кандидатов отбираются для следующей итерации, на которую выделяется больше ресурсов. Для настройки параметров ресурсом обычно является количество обучающих выборок, но это может быть и произвольный числовой параметр, такой как n_estimators в случайном лесу.

Как показано на рисунке ниже, до последней итерации “доживает” только подмножество кандидатов. Это те кандидаты, которые постоянно занимают одно из первых мест во всех итерациях. В каждой итерации на одного кандидата выделяется все больше ресурсов, здесь - количество образцов.

Здесь мы кратко описываем основные параметры, но более подробно каждый параметр и их взаимодействие описаны в следующих разделах. Параметр factor (> 1) управляет скоростью роста ресурсов и скоростью уменьшения числа кандидатов. На каждой итерации количество ресурсов на одного кандидата умножается на factor, а количество кандидатов делится на тот же фактор. Наряду с resource и min_resources, factor является наиболее важным параметром для управления поиском в нашей реализации, хотя обычно хорошо работает значение 3. factor эффективно управляет количеством итераций в HalvingGridSearchCV и количеством кандидатов (по умолчанию) и итераций в HalvingRandomSearchCV. aggressive_elimination=True также может быть использовано, если количество доступных ресурсов невелико. Больше контроля можно получить, настроив параметр min_resources.

Эти модели все еще являются экспериментальными: их прогнозы и API могут измениться без какого-либо цикла устаревания. Чтобы использовать их, необходимо явно импортировать enable_halving_search_cv:

>>> # explicitly require this experimental feature
>>> from sklearn.experimental import enable_halving_search_cv  # noqa
>>> # now you can import normally from model_selection
>>> from sklearn.model_selection import HalvingGridSearchCV
>>> from sklearn.model_selection import HalvingRandomSearchCV

Примеры:

• Comparison between grid search and successive halving

• Successive Halving Iterations

3.2.3.1. Выбор min_resources и количества кандидатов

Помимо factor, двумя основными параметрами, влияющими на поведение последовательного поиска по методу халвинга, являются параметр min_resources и количество кандидатов (или комбинаций параметров), которые оцениваются. min_resources - это количество ресурсов, выделяемых на первой итерации для каждого кандидата. Количество кандидатов задается непосредственно в HalvingRandomSearchCV, и определяется из параметра param_grid HalvingGridSearchCV.

Рассмотрим случай, когда ресурсом является количество образцов, и когда у нас есть 1000 образцов. Теоретически, при min_resources=10 и factor=2 мы можем выполнить не более 7 итераций со следующим количеством образцов: [10, 20, 40, 80, 160, 320, 640].

Но в зависимости от количества кандидатов, мы можем выполнить меньше 7 итераций: если мы начинаем с малого количества кандидатов, последняя итерация может использовать менее 640 образцов, что означает неиспользование всех доступных ресурсов (образцов). Например, если мы начинаем с 5 кандидатов, нам потребуется всего 2 итерации: 5 кандидатов для первой итерации, затем 5 // 2 = 2 кандидатов на второй итерации, после которой мы знаем, какой кандидат работает лучше всего (поэтому нам не нужен третий). Мы будем использовать не более 20 образцов, что является расточительством, поскольку в нашем распоряжении 1000 образцов. С другой стороны, если мы начнем с высокого числа кандидатов, то на последней итерации у нас может оказаться много кандидатов, что не всегда идеально: это означает, что многие кандидаты будут работать с использованием всех ресурсов, что, по сути, сводит процедуру к стандартному поиску.

В случае HalvingRandomSearchCV, количество кандидатов по умолчанию устанавливается таким образом, чтобы на последней итерации использовалось как можно больше доступных ресурсов. Для HalvingGridSearchCV количество кандидатов определяется параметром param_grid. Изменение значения параметра min_resources влияет на количество возможных итераций и, как следствие, на идеальное количество кандидатов.

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

Обратите внимание, что в примере выше последняя итерация не использует максимальное количество доступных ресурсов: Доступно 1000 образцов, но используется только 640, не более. По умолчанию и HalvingRandomSearchCV, и HalvingGridSearchCV пытаются использовать как можно больше ресурсов в последней итерации, с ограничением, и это количество ресурсов должно быть кратно как min_resources, так и factor (это ограничение будет понятно в следующем разделе). HalvingRandomSearchCV достигает этого путем выборки нужного количества кандидатов, а HalvingGridSearchCV достигает этого путем правильного задания min_resources. Подробности смотрите в Исчерпание доступных ресурсов.

3.2.3.2. Количество ресурсов и количество кандидатов на каждой итерации

На любой итерации i, каждому кандидату выделяется определенное количество ресурсов, которое мы обозначаем n_resources_i. Это количество контролируется параметрами factor и min_resources следующим образом (factor строго больше 1):

n_resources_i = factor**i * min_resources,

или эквивалентно:

n_resources_{i+1} = n_resources_i * factor

где min_resources == n_resources_0 - количество ресурсов, используемых на первой итерации. factor также определяет пропорции кандидатов, которые будут выбраны для следующей итерации:

n_candidates_i = n_candidates // (factor ** i)

или эквивалентно:

n_candidates_0 = n_candidates
n_candidates_{i+1} = n_candidates_i // factor

Таким образом, в первой итерации мы используем min_resources ресурсы n_candidates раз. Во второй итерации мы используем min_resources * factor ресурсы n_candidates // factor раз. На третьей снова умножаем ресурсы на одного кандидата и делим на количество кандидатов.

Этот процесс останавливается, когда достигается максимальное количество ресурсов на одного кандидата или когда мы определили лучшего кандидата. Лучший кандидат определяется на той итерации, которая оценивает фактор или меньше кандидатов (объяснение см. чуть ниже).

Вот пример с min_resources=3 и factor=2, начинающийся с 70 кандидатов:

n_resources_i	n_candidates_i
3 (=min_resources)	70 (=n_candidates)
3 * 2 = 6	70 // 2 = 35
6 * 2 = 12	35 // 2 = 17
12 * 2 = 24	17 // 2 = 8
24 * 2 = 48	8 // 2 = 4
48 * 2 = 96	4 // 2 = 2

Мы можем заметить, что:

• процесс останавливается на первой итерации, которая оценивает factor=2 кандидатов: лучший кандидат - это лучший из этих 2 кандидатов. Нет необходимости запускать дополнительную итерацию, так как она будет оценивать только одного кандидата (а именно лучшего, которого мы уже определили). По этой причине, в общем случае, мы хотим, чтобы на последней итерации оценивалось не более factor кандидатов. Если на последней итерации оценивается больше factor кандидатов, то эта последняя итерация сводится к обычному поиску (как в RandomizedSearchCV или GridSearchCV).

• каждое n_resources_i кратно как factor, так и min_resources (что подтверждается его определением выше).

Количество ресурсов, которое используется на каждой итерации, можно найти в атрибуте n_resources_.

3.2.3.3. Выбор ресурса

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

>>> from sklearn.datasets import make_classification
>>> from sklearn.ensemble import RandomForestClassifier
>>> from sklearn.experimental import enable_halving_search_cv  # noqa
>>> from sklearn.model_selection import HalvingGridSearchCV
>>> import pandas as pd
>>>
>>> param_grid = {'max_depth': [3, 5, 10],
...               'min_samples_split': [2, 5, 10]}
>>> base_estimator = RandomForestClassifier(random_state=0)
>>> X, y = make_classification(n_samples=1000, random_state=0)
>>> sh = HalvingGridSearchCV(base_estimator, param_grid, cv=5,
...                          factor=2, resource='n_estimators',
...                          max_resources=30).fit(X, y)
>>> sh.best_estimator_
RandomForestClassifier(max_depth=5, n_estimators=24, random_state=0)

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

3.2.3.4. Исчерпание доступных ресурсов

Как упоминалось выше, количество ресурсов, используемых на каждой итерации, зависит от параметра min_resources.

Если у вас много доступных ресурсов, но вы начинаете с малого количества ресурсов, некоторые из них могут быть потрачены впустую (т. е. не использованы):

>>> from sklearn.datasets import make_classification
>>> from sklearn.svm import SVC
>>> from sklearn.experimental import enable_halving_search_cv  # noqa
>>> from sklearn.model_selection import HalvingGridSearchCV
>>> import pandas as pd
>>> param_grid= {'kernel': ('linear', 'rbf'),
...              'C': [1, 10, 100]}
>>> base_estimator = SVC(gamma='scale')
>>> X, y = make_classification(n_samples=1000)
>>> sh = HalvingGridSearchCV(base_estimator, param_grid, cv=5,
...                          factor=2, min_resources=20).fit(X, y)
>>> sh.n_resources_
[20, 40, 80]

Процесс поиска будет использовать максимум 80 ресурсов, в то время как наше максимальное количество доступных ресурсов равно n_samples=1000. Здесь у нас min_resources = r_0 = 20.

Для HalvingGridSearchCV, по умолчанию, параметр min_resources установлен в ‘exhaust’. Это означает, что min_resources автоматически устанавливается таким образом, чтобы последняя итерация использовала как можно больше ресурсов в пределах ограничения max_resources:

>>> sh = HalvingGridSearchCV(base_estimator, param_grid, cv=5,
...                          factor=2, min_resources='exhaust').fit(X, y)
>>> sh.n_resources_
[250, 500, 1000]

min_resources здесь было автоматически установлено на 250, что приводит к тому, что последняя итерация использует все ресурсы. Точное значение, которое используется, зависит от количества параметров-кандидатов, от max_resources и от factor.

Для HalvingRandomSearchCV, исчерпание ресурсов может быть сделано двумя способами:

• установив min_resources='exhaust', как и для HalvingGridSearchCV;

• задав n_candidates='exhaust'.

Оба варианта являются взаимоисключающими: использование min_resources='exhaust' требует знания количества кандидатов, и симметрично n_candidates='exhaust' требует знания min_resources.

В общем случае исчерпание общего числа ресурсов приводит к лучшему конечному параметру кандидата, но требует немного больше времени.

3.2.3.5. Агрессивное исключение кандидатов

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

>>> from sklearn.datasets import make_classification
>>> from sklearn.svm import SVC
>>> from sklearn.experimental import enable_halving_search_cv  # noqa
>>> from sklearn.model_selection import HalvingGridSearchCV
>>> import pandas as pd
>>>
>>>
>>> param_grid = {'kernel': ('linear', 'rbf'),
...               'C': [1, 10, 100]}
>>> base_estimator = SVC(gamma='scale')
>>> X, y = make_classification(n_samples=1000)
>>> sh = HalvingGridSearchCV(base_estimator, param_grid, cv=5,
...                          factor=2, max_resources=40,
...                          aggressive_elimination=False).fit(X, y)
>>> sh.n_resources_
[20, 40]
>>> sh.n_candidates_
[6, 3]

Поскольку мы не можем использовать более max_resources=40 ресурсов, процесс должен остановиться на второй итерации, которая оценивает более factor=2 кандидатов.

Используя параметр aggressive_elimination, вы можете заставить процесс поиска завершить его на последней итерации с числом кандидатов меньше factor. Для этого процесс исключит столько кандидатов, сколько необходимо, используя параметр min_resources:

>>> sh = HalvingGridSearchCV(base_estimator, param_grid, cv=5,
...                            factor=2,
...                            max_resources=40,
...                            aggressive_elimination=True,
...                            ).fit(X, y)
>>> sh.n_resources_
[20, 20,  40]
>>> sh.n_candidates_
[6, 3, 2]

Обратите внимание, что на последней итерации у нас осталось 2 кандидата, так как мы отсеяли достаточно кандидатов во время первых итераций, используя n_resources = min_resources = 20.

3.2.3.6. Анализ результатов с помощью атрибута cv_results_

Атрибут cv_results_ содержит полезную информацию для анализа результатов поиска. Его можно преобразовать в кадр данных pandas с помощью команды df = pd.DataFrame(est.cv_results_). Атрибут cv_results_ для HalvingGridSearchCV и HalvingRandomSearchCV аналогичен атрибуту GridSearchCV и RandomizedSearchCV, с дополнительной информацией, связанной с процессом последовательного халвинга (successive halving process).

Вот пример с некоторыми столбцами (усеченного) фрейма данных:

	iter	n_resources	mean_test_score	params
0	0	125	0.983667	{‘criterion’: ‘log_loss’, ‘max_depth’: None, ‘max_features’: 9, ‘min_samples_split’: 5}
1	0	125	0.983667	{‘criterion’: ‘gini’, ‘max_depth’: None, ‘max_features’: 8, ‘min_samples_split’: 7}
2	0	125	0.983667	{‘criterion’: ‘gini’, ‘max_depth’: None, ‘max_features’: 10, ‘min_samples_split’: 10}
3	0	125	0.983667	{‘criterion’: ‘log_loss’, ‘max_depth’: None, ‘max_features’: 6, ‘min_samples_split’: 6}
…	…	…	…	…
15	2	500	0.951958	{‘criterion’: ‘log_loss’, ‘max_depth’: None, ‘max_features’: 9, ‘min_samples_split’: 10}
16	2	500	0.947958	{‘criterion’: ‘gini’, ‘max_depth’: None, ‘max_features’: 10, ‘min_samples_split’: 10}
17	2	500	0.951958	{‘criterion’: ‘gini’, ‘max_depth’: None, ‘max_features’: 10, ‘min_samples_split’: 4}
18	3	1000	0.961009	{‘criterion’: ‘log_loss’, ‘max_depth’: None, ‘max_features’: 9, ‘min_samples_split’: 10}
19	3	1000	0.955989	{‘criterion’: ‘gini’, ‘max_depth’: None, ‘max_features’: 10, ‘min_samples_split’: 4}

Каждая строка соответствует заданной комбинации параметров (кандидату) и заданной итерации. Итерация задается столбцом iter. Столбец n_resources говорит о том, сколько ресурсов было использовано.

В приведенном примере наилучшей комбинацией параметров является {'criterion': 'log_loss', 'max_depth': None, 'max_features': 9, 'min_samples_split': 10}, поскольку она достигла последней итерации (3) с наивысшей оценкой: 0.96.

Ссылки:

[1]

K. Jamieson, A. Talwalkar, Non-stochastic Best Arm Identification and Hyperparameter Optimization, in proc. of Machine Learning Research, 2016.

[2]

L. Li, K. Jamieson, G. DeSalvo, A. Rostamizadeh, A. Talwalkar, Hyperband: A Novel Bandit-Based Approach to Hyperparameter Optimization, in Machine Learning Research 18, 2018.

3.2.4. Советы по поиску параметров

3.2.4.1. Указание объективной метрики

По умолчанию поиск параметров использует функцию score модели для оценки настройки параметров. Это функция Оценка точности (accuracy) для классификации и Оценка R², коэффициент детерминации для регрессии. Для некоторых приложений лучше подходят другие функции оценки (например, в несбалансированной классификации оценка точности часто неинформативна). Альтернативная функция оценки может быть задана через параметр scoring большинства инструментов поиска параметров. Более подробную информацию см. в Параметр scoring: определение правил оценки модели.

3.2.4.2. Указание нескольких метрик для оценки

GridSearchCV и RandomizedSearchCV позволяют указывать несколько метрик для параметра scoring.

Несколько оценок может быть указан либо как список строк предопределенных имен оценок, либо как dict, отображающий имя оценки на функцию оценки и/или предопределенные имена оценок. Подробнее см. в Использование множественной метрической оценки.

При указании нескольких метрик, параметр refit должен быть установлен в метрику (строку), для которой будет найдена best_params_ и использована для построения best_estimator_ на всем наборе данных. Если поиск не должен быть refit, задайте refit=False. Если оставить для refit значение по умолчанию None, это приведет к ошибке при использовании нескольких метрик.

Пример использования см. в Demonstration of multi-metric evaluation on cross_val_score and GridSearchCV.

HalvingRandomSearchCV и HalvingGridSearchCV не поддерживают несколько оценкок.

3.2.4.3. Составные оценки и пространства параметров

GridSearchCV и RandomizedSearchCV разрешить поиск по параметрам составных или вложенных оценок, таких как Pipeline, ColumnTransformer, VotingClassifier или CalibratedClassifierCV используя выделенный синтаксис <estimator>__<parameter>:

>>> from sklearn.model_selection import GridSearchCV
>>> from sklearn.calibration import CalibratedClassifierCV
>>> from sklearn.ensemble import RandomForestClassifier
>>> from sklearn.datasets import make_moons
>>> X, y = make_moons()
>>> calibrated_forest = CalibratedClassifierCV(
...    estimator=RandomForestClassifier(n_estimators=10))
>>> param_grid = {
...    'estimator__max_depth': [2, 4, 6, 8]}
>>> search = GridSearchCV(calibrated_forest, param_grid, cv=5)
>>> search.fit(X, y)
GridSearchCV(cv=5,
             estimator=CalibratedClassifierCV(...),
             param_grid={'estimator__max_depth': [2, 4, 6, 8]})

Здесь <estimator> - это имя параметра вложенной модели, в данном случае estimator.

Если метаоценка построена как коллекция оценок, как в pipeline.Pipeline, то <estimator> ссылается на имя оценки, см. Доступ к вложенным параметрам. На практике может быть несколько уровней вложенности:

>>> from sklearn.pipeline import Pipeline
>>> from sklearn.feature_selection import SelectKBest
>>> pipe = Pipeline([
...    ('select', SelectKBest()),
...    ('model', calibrated_forest)])
>>> param_grid = {
...    'select__k': [1, 2],
...    'model__estimator__max_depth': [2, 4, 6, 8]}
>>> search = GridSearchCV(pipe, param_grid, cv=5).fit(X, y)

Обратитесь к Конвейер: цепочка оценок для выполнения поиска параметров по конвейерам.

3.2.4.4. Выбор модели: разработка и оценка

Выбор модели путем оценки различных параметров можно рассматривать как способ использования помеченных данных для “обучения” параметров сетки.

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

Это можно сделать с помощью служебной функции train_test_split.

3.2.4.5. Параллелизм

Инструменты поиска параметров оценивают каждую комбинацию параметров на каждом фолде данных независимо. Вычисления можно выполнять параллельно, используя ключевое слово n_jobs=-1. Более подробную информацию см. в сигнатуре функции, а также в глоссарии для n_jobs.

3.2.4.6. Устойчивость к сбоям

Некоторые настройки параметров могут привести к тому, что один или несколько фолдов данных не будут обучаться (метод fit). По умолчанию это приводит к неудаче всего поиска, даже если некоторые параметры могут быть полностью оценены. Установка error_score=0 (или =np.nan`) сделает процедуру устойчивой к таким неудачам, выдавая предупреждение и устанавливая оценку для этого фолда в 0 (или nan), но завершая поиск.

3.2.5. Альтернативы грубому поиску параметров

3.2.5.1. Кросс-валидация для конкретной модели

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

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

Вот список таких моделей:

linear_model.ElasticNetCV(*[, l1_ratio, ...])	Elastic Net model with iterative fitting along a regularization path.
linear_model.LarsCV(*[, fit_intercept, ...])	Cross-validated Least Angle Regression model.
linear_model.LassoCV(*[, eps, n_alphas, ...])	Lasso linear model with iterative fitting along a regularization path.
linear_model.LassoLarsCV(*[, fit_intercept, ...])	Cross-validated Lasso, using the LARS algorithm.
linear_model.LogisticRegressionCV(*[, Cs, ...])	Logistic Regression CV (aka logit, MaxEnt) classifier.
linear_model.MultiTaskElasticNetCV(*[, ...])	Multi-task L1/L2 ElasticNet with built-in cross-validation.
linear_model.MultiTaskLassoCV(*[, eps, ...])	Multi-task Lasso model trained with L1/L2 mixed-norm as regularizer.
linear_model.OrthogonalMatchingPursuitCV(*)	Cross-validated Orthogonal Matching Pursuit model (OMP).
linear_model.RidgeCV([alphas, ...])	Ridge regression with built-in cross-validation.
linear_model.RidgeClassifierCV([alphas, ...])	Ridge classifier with built-in cross-validation.

3.2.5.2. Информационный критерий

Некоторые модели могут предложить информационно-теоретическую замкнутую формулу оптимальной оценки параметра регуляризации путем вычисления одного пути регуляризации (вместо нескольких при использовании кросс-валидации).

Здесь приведен список моделей, в которых для автоматизированного выбора модели используется информационный критерий Акаике (Akaike Information Criterion - AIC) или байесовский информационный критерий (Bayesian Information Criterion - BIC):

linear_model.LassoLarsIC([criterion, ...])

Lasso model fit with Lars using BIC or AIC for model selection.

3.2.5.3. Out of Bag Оценка

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

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

В настоящее время это реализовано в следующих классах:

ensemble.RandomForestClassifier([...])	A random forest classifier.
ensemble.RandomForestRegressor([...])	A random forest regressor.
ensemble.ExtraTreesClassifier([...])	An extra-trees classifier.
ensemble.ExtraTreesRegressor([n_estimators, ...])	An extra-trees regressor.
ensemble.GradientBoostingClassifier(*[, ...])	Gradient Boosting for classification.
ensemble.GradientBoostingRegressor(*[, ...])	Gradient Boosting for regression.