Spec-Zone.ru › scikit-learn

Примечание

Перейти в конец, чтобы скачать полный код примера или запустить этот пример в браузере с помощью JupyterLite или Binder.

Итерации последовательного сокращения

В этом примере показано, как поиск методом последовательного сокращения (HalvingGridSearchCV и HalvingRandomSearchCV) итеративно выбирает наилучшую комбинацию параметров из множества кандидатов.

# Authors: The scikit-learn developers
# SPDX-License-Identifier: BSD-3-Clause

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from scipy.stats import randint

from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier
from sklearn.experimental import enable_halving_search_cv  # noqa: F401
from sklearn.model_selection import HalvingRandomSearchCV

Сначала мы определяем пространство параметров и обучаем экземпляр HalvingRandomSearchCV.

rng = np.random.RandomState(0)

X, y = datasets.make_classification(n_samples=400, n_features=12, random_state=rng)

clf = RandomForestClassifier(n_estimators=20, random_state=rng)

param_dist = {
    "max_depth": [3, None],
    "max_features": randint(1, 6),
    "min_samples_split": randint(2, 11),
    "bootstrap": [True, False],
    "criterion": ["gini", "entropy"],
}

rsh = HalvingRandomSearchCV(
    estimator=clf, param_distributions=param_dist, factor=2, random_state=rng
)
rsh.fit(X, y)
HalvingRandomSearchCV(estimator=RandomForestClassifier(n_estimators=20,
                                                       random_state=RandomState(MT19937) at 0x784166B66A40),
                      factor=2,
                      param_distributions={'bootstrap': [True, False],
                                           'criterion': ['gini', 'entropy'],
                                           'max_depth': [3, None],
                                           'max_features': <scipy.stats._distn_infrastructure.rv_discrete_frozen object at 0x784129d35e50>,
                                           'min_samples_split': <scipy.stats._distn_infrastructure.rv_discrete_frozen object at 0x78416c563490>},
                      random_state=RandomState(MT19937) at 0x784166B66A40)
В среде Jupyter повторно выполните эту ячейку, чтобы отобразить HTML-представление, или доверьте этому блокноту выполнение.
На GitHub HTML-представление не отображается. Попробуйте открыть эту страницу с помощью nbviewer.org.
Параметры
estimator estimator: объект оценщика

Предполагается, что он реализует интерфейс оценщика scikit-learn.
Оценщик должен предоставлять функцию ``score``
или необходимо передать ``scoring``.
RandomForestC...x784166B66A40)
param_distributions param_distributions: словарь или список словарей

Словарь, в котором имена параметров (`str`) являются ключами, а значения — распределениями
или списками параметров для проверки. Распределения должны предоставлять метод ``rvs``
для выборки (например, распределения из scipy.stats.distributions).
Если передан список, выборка из него производится равномерно.
Если передан список словарей, сначала равномерно выбирается словарь,
а затем параметр выбирается с помощью этого словаря, как описано выше.
{'bootstrap': [True, False], 'criterion': ['gini', 'entropy'], 'max_depth': [3, None], 'max_features': <scipy.stats....x784129d35e50>, ...}
factor factor: int или float, по умолчанию=3

Параметр «halving», определяющий долю кандидатов,
которые отбираются для каждой следующей итерации. Например,
``factor=3`` означает, что отбирается только треть кандидатов.
2
random_state random_state: int, экземпляр RandomState или None, по умолчанию=None

Состояние генератора псевдослучайных чисел, используемое для подвыборки набора данных,
если `resources != 'n_samples'`. Также используется для равномерной случайной
выборки из списков возможных значений вместо распределений scipy.stats.
Передайте int, чтобы получать воспроизводимый результат при нескольких вызовах функции.
См. :term:`Глоссарий <random_state>`.
RandomState(M...0x784166B66A40
n_candidates n_candidates: «exhaust» или int, по умолчанию=«exhaust»

Количество параметров-кандидатов для выборки на первой
итерации. Значение 'exhaust' выбирает достаточно кандидатов, чтобы на последней итерации
использовалось как можно больше ресурсов с учётом
`min_resources`, `max_resources` и `factor`. В этом случае
`min_resources` не может быть равен 'exhaust'.
'exhaust'
resource resource: ``'n_samples'`` или str, по умолчанию='n_samples'

Задаёт ресурс, объём которого увеличивается на каждой итерации. По умолчанию
ресурсом является количество образцов. Также можно задать любой
параметр базового оценщика, принимающий положительные целочисленные
значения, например 'n_iterations' или 'n_estimators' для оценщика градиентного
бустинга. В этом случае ``max_resources`` не может быть равен 'auto'
и должен быть задан явно.
'n_samples'
max_resources max_resources: int, по умолчанию='auto'

Максимальный объём ресурсов, который разрешено использовать каждому кандидату
на заданной итерации. По умолчанию это значение ``n_samples``, если
``resource='n_samples'`` (по умолчанию); в противном случае возникает ошибка.
'auto'
min_resources min_resources: {'exhaust', 'smallest'} или int, по умолчанию='smallest'

Минимальный объём ресурсов, который разрешено использовать каждому кандидату
на заданной итерации. Иными словами, этот параметр задаёт объём
ресурсов `r0`, выделяемый каждому кандидату на первой
итерации.

- 'smallest' — эвристика, задающая небольшое значение `r0`:

- ``n_splits * 2`` при ``resource='n_samples'`` для задачи регрессии
- ``n_classes * n_splits * 2`` при ``resource='n_samples'`` для
задачи классификации
- ``1`` при ``resource != 'n_samples'``

- 'exhaust' задаёт `r0` так, чтобы на **последней** итерации использовалось
как можно больше ресурсов. В частности, на последней итерации будет использоваться
наибольшее значение, меньшее ``max_resources`` и кратное одновременно
``min_resources`` и ``factor``. В целом использование 'exhaust'
позволяет получить более точный оценщик, но требует немного больше времени.
Значение 'exhaust' недоступно, если `n_candidates='exhaust'`.

Обратите внимание: объём ресурсов, используемых на каждой итерации, всегда кратен
``min_resources``.
'smallest'
aggressive_elimination aggressive_elimination: bool, по умолчанию=False

Этот параметр имеет значение только в случаях, когда ресурсов недостаточно,
чтобы после последней итерации сократить число оставшихся кандидатов до `factor` или меньше.
Если ``True``, процесс поиска будет «повторять»
первую итерацию столько раз, сколько потребуется, пока число кандидатов
не станет достаточно малым. По умолчанию задано ``False``, поэтому
на последней итерации может оцениваться более ``factor`` кандидатов. Подробнее см.
:ref:`aggressive_elimination`.
False
cv cv: int, генератор перекрёстной проверки или итерируемый объект, по умолчанию=5

Определяет стратегию разбиения для перекрёстной проверки.
Для cv допустимы следующие значения:

- целое число — задаёт число фолдов в `(Stratified)KFold`,
- :term:`разбиение CV`,
- итерируемый объект, возвращающий разбиения (train, test) в виде массивов индексов.

Для целочисленных значений и None, если оценщик является классификатором, а ``y`` —
бинарная переменная или переменная с несколькими классами, используется :class:`StratifiedKFold`. Во всех
остальных случаях используется :class:`KFold`. Эти разбиения создаются
с параметром `shuffle=False`, поэтому при каждом вызове разбиения будут одинаковыми.

Различные стратегии перекрёстной проверки, доступные здесь, описаны в
:ref:`руководстве пользователя <cross_validation>`.

.. note::
Из-за особенностей реализации фолды, созданные с помощью `cv`, должны
оставаться одинаковыми при нескольких вызовах `cv.split()`. Для
встроенных итераторов `scikit-learn` этого можно добиться,
отключив перемешивание (`shuffle=False`) или задав целочисленное значение
параметра `random_state` в `cv`.
5
scoring scoring: str или вызываемый объект, по умолчанию=None

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

- str: варианты см. в :ref:`названиях строковых метрик scoring_string_names`.
- вызываемый объект: вызываемый объект-оценщик (например, функция) с сигнатурой
``scorer(estimator, X, y)``. Подробнее см. :ref:`scoring_callable`.
- `None`: используется :ref:`критерий оценки по умолчанию для оценщика <scoring_api_overview>`.
None
refit refit: bool или вызываемый объект, по умолчанию=True

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

Если при выборе наилучшего оценщика необходимо учитывать не только максимальную оценку,
для ``refit`` можно задать функцию, которая
возвращает выбранный ``best_index_`` на основе ``cv_results_``. В этом
случае ``best_estimator_`` и ``best_params_`` будут установлены
в соответствии с возвращённым ``best_index_``, а атрибут ``best_score_``
будет недоступен.

Повторно обученный оценщик доступен через атрибут ``best_estimator_``
и позволяет напрямую вызывать ``predict`` для этого экземпляра
``HalvingRandomSearchCV``.

Пример использования ``refit=callable`` для балансировки сложности модели
и оценки при перекрёстной проверке приведён в
:ref:`этом примере
<sphx_glr_auto_examples_model_selection_plot_grid_search_refit_callable.py>`.
True
error_score error_score: 'raise' или числовое значение

Значение, присваиваемое оценке, если при обучении оценщика возникает ошибка.
Если задано значение 'raise', ошибка будет вызвана повторно. Если указано числовое значение,
будет вызвано предупреждение FitFailedWarning. Этот параметр не влияет на этап повторного обучения,
на котором ошибка будет вызвана в любом случае. Значение по умолчанию — ``np.nan``.
nan
return_train_score return_train_score: bool, по умолчанию=False

Если задано ``False``, атрибут ``cv_results_`` не будет содержать оценки
на обучающей выборке.
Расчёт оценок на обучающей выборке позволяет понять, как разные
значения параметров влияют на компромисс между переобучением и недообучением.
Однако вычисление оценок на обучающей выборке может требовать значительных вычислительных ресурсов
и не является строго необходимым для выбора параметров,
обеспечивающих наилучшее качество обобщения.
True
n_jobs n_jobs: int или None, по умолчанию=None

Количество задач, выполняемых параллельно.
``None`` означает 1, если только не используется контекст :obj:`joblib.parallel_backend`.
``-1`` означает использование всех процессоров. Подробнее см. :term:`Глоссарий <n_jobs>`.
None
verbose verbose: int

Управляет подробностью вывода: чем выше значение, тем больше сообщений.
0
Обученные атрибуты
Имя Тип Значение
best_estimator_ best_estimator_: estimator or dict

Оцениватель, выбранный в результате поиска, то есть оцениватель,
который показал наивысший результат (или наименьшие потери, если это указано)
на отложенных данных. Недоступен, если ``refit=False``.
RandomForestClassifier RandomForestC...x784117609540)
best_index_ best_index_: int

Индекс (в массивах ``cv_results_``), соответствующий наилучшему
набору параметров-кандидатов.

Словарь по адресу ``search.cv_results_['params'][search.best_index_]`` содержит
настройки параметров для наилучшей модели, обеспечившей наивысший
средний результат (``search.best_score_``).
int64 np.int64(39)
best_params_ best_params_: dict

Настройки параметров, обеспечившие наилучшие результаты на отложенных данных.
dict {'bo...ap': False, 'cr...on': 'entropy', 'ma...th': None, 'ma...es': 4, ...}
best_score_ best_score_: float

Средний результат кросс-валидации для best_estimator.
float64 0.8875
classes_ classes_: ndarray of shape (n_classes,)

Метки классов. Атрибут присутствует, только если указан ``refit`` и
базовый оцениватель является классификатором.
ndarray[int64](2,) [0,1]
cv_results_ cv_results_: dict of numpy (masked) ndarrays

Словарь, в котором ключи — это заголовки столбцов, а значения — столбцы; его можно
импортировать в ``DataFrame`` pandas. Он содержит множество сведений
для анализа результатов поиска.
Подробнее см. в :ref:`руководстве пользователя<successive_halving_cv_results>`.
Пример анализа ``cv_results_`` см. в разделе
:ref:`sphx_glr_auto_examples_model_selection_plot_grid_search_stats.py`.
dict {'iter': array([0, 0, ..., 3, 3, 4, 4]), 'me...me': array([0.03, ..., 0.03, 0.04]), 'me...me': array([0. , ..., 0. , 0. ]), 'me...re': array([0.65, ..., 0.88, 0.89]), ...}
max_resources_ max_resources_: int

Максимальное число ресурсов, которое может использовать любой кандидат
в данной итерации. Обратите внимание: поскольку число ресурсов, используемых на
каждой итерации, должно быть кратно ``min_resources_``, фактическое
число ресурсов, использованных на последней итерации, может быть меньше,
чем ``max_resources_``.
int 400
min_resources_ min_resources_: int

Количество ресурсов, выделяемых каждому кандидату на
первой итерации.
int 20
multimetric_ multimetric_: bool

Вычисляют ли функции оценки несколько метрик.
bool False
n_candidates_ n_candidates_: list of int

Число параметров-кандидатов, оценённых на каждой
итерации.
list [20, 10, 5, 3, ...]
n_features_in_ n_features_in_: int

Число признаков, обнаруженных во время :term:`fit`. Определён только если
определён `best_estimator_` (подробности см. в документации к параметру `refit`)
и этот `best_estimator_` предоставляет атрибут
`n_features_in_` после обучения.

.. versionadded:: 0.24
int 12
n_iterations_ n_iterations_: int

Фактическое число выполненных итераций. Равно
``n_required_iterations_``, если ``aggressive_elimination`` имеет значение ``True``.
В противном случае равно ``min(n_possible_iterations_,
n_required_iterations_)``.
int 5
n_possible_iterations_ n_possible_iterations_: int

Число итераций, которые можно выполнить, начиная с
ресурсов ``min_resources_`` и не превышая
``max_resources_``.
int 5
n_remaining_candidates_ n_remaining_candidates_: int

Число параметров-кандидатов, оставшихся после последней
итерации. Соответствует `ceil(n_candidates[-1] / factor)`
int 1
n_required_iterations_ n_required_iterations_: int

Число итераций, необходимых для того, чтобы на последней итерации осталось менее
``factor`` кандидатов, начиная с ресурсов
``min_resources_``. Это значение будет меньше
``n_possible_iterations_``, если ресурсов недостаточно.
int 5
n_resources_ n_resources_: list of int

Количество ресурсов, использованных на каждой итерации.
list [20, 40, 80, 160, ...]
n_splits_ n_splits_: int

Число разбиений кросс-валидации (фолдов/итераций).
int 5
refit_time_ refit_time_: float

Время в секундах, затраченное на повторное обучение наилучшей модели на всём наборе данных.

Присутствует только если ``refit`` не равно False.
float 0.04359
scorer_ scorer_: function or a dict

Функция оценки, применённая к отложенным данным для выбора наилучших
параметров модели.
_PassthroughScorer RandomForestClassifier.score
RandomForestClassifier(bootstrap=False, criterion='entropy', max_features=4,
                       min_samples_split=5, n_estimators=20,
                       random_state=RandomState(MT19937) at 0x784117609540)
Параметры
n_estimators n_estimators: int, default=100

Количество деревьев в ансамбле.

.. versionchanged:: 0.22
Значение ``n_estimators`` по умолчанию изменилось с 10 на 100
в версии 0.22.
20
criterion criterion: {"gini", "entropy", "log_loss"}, default="gini"

Функция для измерения качества разбиения. Поддерживаются следующие критерии:
"gini" для неоднородности Джини, а также "log_loss" и "entropy" для
информационного прироста Шеннона; см. :ref:`tree_mathematical_formulation`.
Примечание: этот параметр относится только к деревьям.
'entropy'
min_samples_split min_samples_split: int or float, default=2

Минимальное количество образцов, необходимое для разбиения внутреннего узла:

- Если задано целое число, `min_samples_split` считается минимальным количеством образцов.
- Если задано число с плавающей точкой, `min_samples_split` — это доля, а
`ceil(min_samples_split * n_samples)` — минимальное
количество образцов для каждого разбиения.

.. versionchanged:: 0.18
Добавлена возможность задавать доли числами с плавающей точкой.
5
max_features max_features: {"sqrt", "log2", None}, int or float, default="sqrt"

Количество признаков, рассматриваемых при поиске наилучшего разбиения:

- Если задано целое число, то при каждом разбиении рассматривается `max_features` признаков.
- Если задано число с плавающей точкой, `max_features` — это доля, и
при каждом разбиении рассматриваются `max(1, int(max_features * n_features_in_))` признаков.
- Если задано "sqrt", то `max_features=sqrt(n_features)`.
- Если задано "log2", то `max_features=log2(n_features)`.
- Если задано None, то `max_features=n_features`.

.. versionchanged:: 1.1
Значение `max_features` по умолчанию изменено с `"auto"` на `"sqrt"`.

Примечание: поиск разбиения не прекращается, пока не будет найдено хотя бы одно
допустимое разбиение образцов узла, даже если для этого потребуется
фактически проверить больше признаков, чем ``max_features``.
4
bootstrap bootstrap: bool, default=True

Использовать ли бутстреп-выборки при построении деревьев. Если False,
для построения каждого дерева используется весь набор данных.
False
random_state random_state: int, RandomState instance or None, default=None

Управляет как случайностью при формировании выборок с возвращением, используемых
при построении деревьев (если ``bootstrap=True``), так и выборкой
признаков, рассматриваемых при поиске наилучшего разбиения в каждом узле
(если ``max_features < n_features``).
Подробности см. в :term:`глоссарии <random_state>`.
RandomState(M...0x784117609540
max_depth max_depth: int, default=None

Максимальная глубина дерева. Если задано None, узлы расширяются до тех пор,
пока все листья не станут чистыми или пока каждый лист не будет содержать меньше
образцов, чем min_samples_split.
None
min_samples_leaf min_samples_leaf: int or float, default=1

Минимальное количество образцов, необходимое в листовом узле.
Точка разбиения на любой глубине будет рассматриваться, только если в каждой из
левой и правой ветвей останется не менее ``min_samples_leaf`` обучающих образцов.
Это может сглаживать модель, особенно в задачах регрессии.

- Если задано целое число, `min_samples_leaf` считается минимальным количеством образцов.
- Если задано число с плавающей точкой, `min_samples_leaf` — это доля, а
`ceil(min_samples_leaf * n_samples)` — минимальное
количество образцов для каждого узла.

.. versionchanged:: 0.18
Добавлена возможность задавать доли числами с плавающей точкой.
1
min_weight_fraction_leaf min_weight_fraction_leaf: float, default=0.0

Минимальная взвешенная доля от общей суммы весов (всех
входных образцов), необходимая для листового узла. Если sample_weight не задан,
образцы имеют одинаковый вес.
0.0
max_leaf_nodes max_leaf_nodes: int, default=None

Выращивать деревья, ограничивая количество листьев значением ``max_leaf_nodes``, в порядке наилучшего первого.
Наилучшие узлы определяются по относительному уменьшению неоднородности.
Если задано None, количество листовых узлов не ограничено.
None
min_impurity_decrease min_impurity_decrease: float, default=0.0

Узел будет разделен, если это разбиение приводит к уменьшению неоднородности
не меньше заданного значения.

Уравнение для взвешенного уменьшения неоднородности имеет следующий вид::

N_t / N * (impurity - N_t_R / N_t * right_impurity
- N_t_L / N_t * left_impurity)

где ``N`` — общее количество образцов, ``N_t`` — количество
образцов в текущем узле, ``N_t_L`` — количество образцов в левом дочернем узле, а ``N_t_R`` — количество образцов в правом дочернем узле.

``N``, ``N_t``, ``N_t_R`` и ``N_t_L`` обозначают взвешенные суммы,
если передан ``sample_weight``.

.. versionadded:: 0.19
0.0
oob_score oob_score: bool or callable, default=False

Использовать ли вневыборочные образцы для оценки качества обобщения.
По умолчанию используется :func:`~sklearn.metrics.accuracy_score`.
Чтобы использовать пользовательскую метрику, передайте вызываемый объект с сигнатурой `metric(y_true, y_pred)`. Доступно только при `bootstrap=True`.

Пример оценки ошибки на вневыборочных образцах (OOB) см. в разделе
:ref:`sphx_glr_auto_examples_ensemble_plot_ensemble_oob.py`.
False
n_jobs n_jobs: int, default=None

Количество заданий, выполняемых параллельно. Методы :meth:`fit`, :meth:`predict`,
:meth:`decision_path` и :meth:`apply` распараллеливаются по
деревьям. ``None`` означает 1, если выполнение не происходит в контексте :obj:`joblib.parallel_backend`.
``-1`` означает использование всех процессоров. Дополнительные сведения см. в :term:`глоссарии
<n_jobs>`.
None
verbose verbose: int, default=0

Управляет подробностью вывода при обучении и предсказании.
0
warm_start warm_start: bool, default=False

Если задано ``True``, повторно используется решение предыдущего вызова fit
и в ансамбль добавляются новые оцениватели; в противном случае обучается совершенно
новый лес. Подробности см. в :term:`глоссарии <warm_start>` и
:ref:`tree_ensemble_warm_start`.
False
class_weight class_weight: {"balanced", "balanced_subsample"}, dict or list of dicts, default=None

Веса классов в формате ``{class_label: weight}``.
Если веса не заданы, считается, что вес всех классов равен единице. Для
задач с несколькими выходами можно передать список словарей в том же
порядке, что и столбцы y.

Обратите внимание: для задач с несколькими выходами (включая многометочную классификацию) веса необходимо
задавать для каждого класса каждого столбца в отдельном словаре. Например,
для многометочной классификации с четырьмя классами веса следует задать так:
[{0: 1, 1: 1}, {0: 1, 1: 5}, {0: 1, 1: 1}, {0: 1, 1: 1}], а не так:
[{1:1}, {2:5}, {3:1}, {4:1}].

Режим "balanced" использует значения y для автоматической корректировки
весов, обратно пропорциональных частотам классов во входных данных,
по формуле ``n_samples / (n_classes * np.bincount(y))``

Режим "balanced_subsample" аналогичен "balanced", но веса вычисляются
на основе бутстреп-выборки для каждого построенного дерева.

Для задач с несколькими выходами веса каждого столбца y перемножаются.

Обратите внимание: если задан sample_weight, эти веса умножаются на sample_weight (передаваемый
в метод fit).
None
ccp_alpha ccp_alpha: non-negative float, default=0.0

Параметр сложности, используемый для минимального отсечения по критерию стоимости и сложности. Будет выбран
подграф с наибольшей стоимостью сложности, меньшей
``ccp_alpha``. По умолчанию отсечение не выполняется. Подробности см.
в :ref:`minimal_cost_complexity_pruning`. Пример такого отсечения см.
в :ref:`sphx_glr_auto_examples_tree_plot_cost_complexity_pruning.py`.

.. versionadded:: 0.22
0.0
max_samples max_samples: int or float, default=None

Если bootstrap имеет значение True, количество образцов, выбираемых из X
для обучения каждого базового оценщика.

- Если значение равно None (по умолчанию), выбираются `X.shape[0]` образцов независимо от
`sample_weight`.
- Если значение — int, выбираются `max_samples` образцов.
- Если значение — float, выбираются `max_samples * X.shape[0]` невзвешенных образцов
или `max_samples * sample_weight.sum()` взвешенных образцов.

.. versionadded:: 0.22

.. versionchanged:: 1.9
Для взвешенных образцов значение float `max_samples` рассчитывается относительно `sample_weight.sum()`, а не
`X.shape[0]`.
None
monotonic_cst monotonic_cst: array-like of int of shape (n_features), default=None

Задает ограничение монотонности, применяемое к каждому признаку.
- 1: монотонное возрастание
- 0: без ограничений
- -1: монотонное убывание

Если monotonic_cst равен None, ограничения не применяются.

Ограничения монотонности не поддерживаются для:
- многоклассовой классификации (то есть когда `n_classes > 2`),
- классификации с несколькими выходами (то есть когда `n_outputs_ > 1`).

Ограничения применяются к вероятности положительного класса.

Подробнее см. в :ref:`руководстве пользователя <monotonic_cst_gbdt>`.

.. versionadded:: 1.4
None
Обученные атрибуты
Имя Тип Значение
classes_ classes_: ndarray формы (n_classes,) или список таких массивов

Метки классов (задача с одним выходом) или список массивов
меток классов (задача с несколькими выходами).
ndarray[int64](2,) [0,1]
estimator_ estimator_: :class:`~sklearn.tree.DecisionTreeClassifier`

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

.. versionadded:: 1.2
`base_estimator_` переименован в `estimator_`.
DecisionTreeClassifier DecisionTreeClassifier()
estimators_ estimators_: список DecisionTreeClassifier

Набор обученных подоценщиков.
list [DecisionTreeC...ate=214286498), DecisionTreeC...ate=631739714), DecisionTreeC...te=1554730159), DecisionTreeC...tate=25323325), ...]
estimators_samples_ estimators_samples_: список массивов

Подмножество выбранных образцов (то есть образцы, попавшие в бутстрэп-выборку) для каждого базового
оценщика. Каждое подмножество задается массивом выбранных индексов.

.. versionadded:: 1.4
list [array([ 0, ..., dtype=int32), array([ 0, ..., dtype=int32), array([ 0, ..., dtype=int32), array([ 0, ..., dtype=int32), ...]
feature_importances_ feature_importances_: ndarray формы (n_features,)

Важность признаков, основанная на нечистоте.
Чем выше значение, тем важнее признак.
Важность признака вычисляется как (нормализованное)
суммарное уменьшение критерия, обеспечиваемое этим признаком. Также известна
как важность Джини.

Предупреждение: важность признаков, основанная на нечистоте, может быть недостоверной для
признаков с высокой кардинальностью (большим количеством уникальных значений). В качестве альтернативы см.
:func:`sklearn.inspection.permutation_importance`.
ndarray[float64](12,) [0.15,0.22,0.02,...,0.02,0.02,0.02]
n_classes_ n_classes_: int или список

Количество классов (задача с одним выходом) или список, содержащий
количество классов для каждого выхода (задача с несколькими выходами).
int 2
n_features_in_ n_features_in_: int

Количество признаков, обнаруженных во время :term:`fit`.

.. versionadded:: 0.24
int 12
n_outputs_ n_outputs_: int

Количество выходов при выполнении ``fit``.
int 1


Теперь мы можем использовать атрибут cv_results_ оценщика поиска, чтобы изучить и построить график изменения результатов поиска.

results = pd.DataFrame(rsh.cv_results_)
results["params_str"] = results.params.apply(str)
results.drop_duplicates(subset=("params_str", "iter"), inplace=True)
mean_scores = results.pivot(
    index="iter", columns="params_str", values="mean_test_score"
)
ax = mean_scores.plot(legend=False, alpha=0.6)

labels = [
    f"iter={i}\nn_samples={rsh.n_resources_[i]}\nn_candidates={rsh.n_candidates_[i]}"
    for i in range(rsh.n_iterations_)
]

ax.set_xticks(range(rsh.n_iterations_))
ax.set_xticklabels(labels, rotation=45, multialignment="left")
ax.set_title("Scores of candidates over iterations")
ax.set_ylabel("mean test score", fontsize=15)
ax.set_xlabel("iterations", fontsize=15)
plt.tight_layout()
plt.show()
Scores of candidates over iterations

Количество кандидатов и объем ресурсов на каждой итерации

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

На второй итерации оценивается только лучшая половина кандидатов. Объем выделяемых ресурсов удваивается: кандидаты оцениваются на вдвое большем количестве образцов.

Этот процесс повторяется до последней итерации, на которой остаются только 2 кандидата. Лучший кандидат — тот, у которого на последней итерации наилучшая оценка.

Общее время выполнения скрипта: (0 минут 7.454 секунды)

Launch binder
Launch JupyterLite

Download Jupyter notebook: plot_successive_halving_iterations.ipynb

Download Python source code: plot_successive_halving_iterations.py

Download zipped: plot_successive_halving_iterations.zip

Связанные примеры

Сравнение случайного поиска и поиска по сетке для оценки гиперпараметров

Сравнение поиска по сетке и последовательного сокращения

Основные нововведения scikit-learn 0.24

Анализ сходимости моделей логистической регрессии со штрафом

© 2007–2026 The scikit-learn developers
Licensed under the 3-clause BSD License.
https://scikit-learn.org/1.9/auto_examples/model_selection/plot_successive_halving_iterations.html

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API