Алгоритм машинного обучения XGBoost

в предыдущем постеМетод бустингаВо введении XGBoost есть краткое введение в XGBoost. Чтобы лучше освоить инструмент XGBoost. Изучим его подробнее.

Что такое XGBoost?

Полное название: eXtreme Gradient Boosting
автор:Чен Тяньци(Доктор философии, Вашингтонский университет)
Основы: ГБДТ
Принадлежит: повышающему итеративному, древовидному алгоритму.
Область применения: классификация, регрессия
Преимущества: быстрая скорость, хороший эффект, возможность обработки больших объемов данных, поддержка нескольких языков, поддержка пользовательских функций потери и т. д.
Недостатки: Параметров алгоритма слишком много, виновата настройка параметров, сложно использовать XGBoost, если принцип не ясен. Не подходит для обработки данных о сверхвысоких размерностях.
адрес проекта:GitHub.com/Но ФРС/Гонконг освистывает…

Принцип XGBoost

Алгоритм, применяемый XGBoost, представляет собой дерево решений для повышения градиента, которое можно использовать как дляКлассификациятакже может использоваться длявозвращениеобсуждаемый. Так что же такое повышение градиента? Градиентный бустинг — один из методов бустинга. так называемый Повышение — это метод объединения слабых разделителей f_i(x) для формирования сильных классификаторов F(x). Итак, Boosting состоит из трех элементов:

Оптимизируемая функция потерь: например, перекрестная энтропия используется в задачах классификации, а среднеквадратическая ошибка — в задачах регрессии.
Слабый ученик, чтобы делать прогнозы: напримерДрево решений.
Аддитивная модель: сильный ученик формируется путем накопления нескольких слабых учеников, чтобы сделать целевую функцию потерь чрезвычайно малой.

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

Преимущества XGBoost

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

Регуляризация. XGBoost добавляет регулярное слагаемое к функции стоимости, чтобы контролировать сложность модели. Обычный член содержит количество листовых узлов дерева и сумму квадратов модуля L2 оценки, выводимой на каждом листовом узле. С точки зрения компромисса между смещением и дисперсией, обычный член уменьшает дисперсию модели, упрощая изученную модель и предотвращая переоснащение, что также является особенностью xgboost по сравнению с традиционным GBDT.
Инструмент XGBoost поддерживает параллелизм. Разве Boosting не является последовательной структурой? Обратите внимание, что параллелизм XGBoost не является параллелизмом детализации дерева, и XGBoost может перейти к следующей итерации только после одной итерации (функция стоимости t-й итерации содержит предсказанное значение предыдущих t-1 итераций). Параллелизм XGBoost заключается в детализации функций. Мы знаем, что одним из самых трудоемких шагов в обучении дерева решений является сортировка значений признаков (потому что необходимо определить наилучшую точку разделения).XGBoost заранее сортирует данные перед обучением, а затем сохраняет их. как блочная структура Повторное использование этой структуры в итерациях значительно сокращает объем вычислений. Эта блочная структура также делает возможным распараллеливание.При разделении узлов необходимо рассчитать усиление каждой функции, и, наконец, для разделения выбирается функция с наибольшим усилением, после чего расчет усиления каждой функции может выполняться в нескольких потоках.
Высокая гибкость. XGBoost поддерживает определяемую пользователем целевую функцию и функцию оценки, если целевая функция является производной второго порядка.
Обработка пропущенных значений. XGBoost имеет встроенные правила для обработки пропущенных значений. Пользователь должен предоставить значение, отличное от других образцов, а затем передать его в качестве параметра, который используется в качестве значения отсутствующего значения. XGBoost применяет разные методы обработки, когда разные узлы сталкиваются с пропущенными значениями, и изучит методы обработки при обнаружении пропущенных значений в будущем.
Обрезка. GBM прекращает разделение, когда при разделении обнаруживается отрицательный убыток. Таким образом, GBM на самом деле является жадным алгоритмом. XGBoost разделится до указанной максимальной глубины (max_depth), а затем вернется и обрежет. Если после узла больше нет положительных значений, он убирает разбиение. Преимущество этого подхода становится очевидным, когда за отрицательным проигрышем (например, -2) следует положительный проигрыш (например, +10). GBM останавливается на -2, потому что встречает отрицательное значение. Но XGBoost продолжит разделение, а затем обнаружит, что два разделения вместе дадут +8, поэтому оба разделения будут сохранены. По сравнению с GBM, найти локальное оптимальное решение непросто.
Встроенная перекрестная проверка. XGBoost позволяет использовать перекрестную проверку на каждой итерации повышения. Поэтому можно легко получить оптимальное количество итераций бустинга. Хотя GBM использует поиск по сетке, он может обнаружить только ограниченное количество значений.
Продолжить на основе существующей модели. XGBoost может продолжить обучение по результатам предыдущего раунда.

Основы — ГБДТ

xgboost является улучшением алгоритма повышения на основе GBDT.Внутреннее дерево решений использует дерево регрессии.Краткий обзор GBDT выглядит следующим образом:

Разделенный узел дерева регрессии:

Для квадратичной функции потерь подбирается невязка;

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

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

Принципиальное знание алгоритма XGBoost

Определение сложности дерева

1. Разделить дерево на часть структуры дерева q и часть веса листа w.

2. Функции сложности дерева и примеры

Причина определения структуры и сложности дерева проста, чтобы можно было измерить сложность модели и эффективно контролировать переоснащение.

прокачка модели дерева в xgboost

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

Переписать целевую функцию - разложение Тейлора второго порядка (ключ)

Окончательная целевая функция зависит только от первой и второй производных функции ошибок для каждой точки данных. Причина этого очевидна. Поскольку предыдущая целевая функция использовалась только для квадрата функции потерь в процессе поиска оптимального решения, для других функций потерь она стала очень сложной. Благодаря преобразованию разложения Тейлора второго порядка она можно решить другие Функция потерь становится допустимой. Когда набор разделенных кандидатов определен $I_j = \{i|q(x_i)=j\}$ . Целевая функция может быть дополнительно изменена. Набор кандидатов для разделенного узла — это очень важный шаг, который является гарантией высокой скорости xgboost.Как выбрать этот набор, будет представлено позже.

Решать:

функция оценки древовидной структуры

Obj представляет собой максимальное сокращение цели при указании древовидной структуры?

За каждую попытку добавить разделение к существующему листу

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

Предположим, вы хотите перечислить все условия, при которых x

Найдите набор кандидатов разделенных узлов

1. Насильственное перечисление

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

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

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

3. Взвешенный квантильный эскиз

Чен Тяньци предложил и доказал взвешенный распределенный квантильный эскиз с вероятностной точки зрения.

Ссылка на ссылку:

у-у-у. yuque.com/7125 какой придурок/ой...
blog.CSDN.net/V_July_V/AR…
в Наньчжоу. Следующая остановка/%E6%B5%85%E…
fuhailin.github.io/XGBoost/

Как использовать XGBoost?

Установка XGBoost

Многие учебники в Интернете учат, как компилировать и устанавливать.Процесс громоздкий.Проще всего загрузить скомпилированные..whl-файлустановить.

Параметры XGBoost

Авторы XGBoost разделили все параметры на три категории:

Общие параметры: управление функцией макроса.
Параметры бустера: управляйте бустером (деревом/регрессией) каждого шага.
Параметры тренировочной цели: контролирует эффективность тренировочной цели.

Здесь мы объясним это по аналогии с GBM, как некое базовое знание.

Общие параметры

Эти параметры используются для управления функциями макросов XGBoost.

бустер [gbtree по умолчанию]Для выбора модели для каждой итерации есть два варианта:
- gbtree: древовидная модель
- gbliner: Линейная модель. Используйте модель линейной регрессии с регуляризацией l1,l2 в качестве базового ученика. Потому что алгоритм бустинга — это процесс линейной суперпозиции, и модель линейной регрессии — это тоже процесс линейной суперпозиции. Следовательно, конечным результатом суперпозиции является общая линейная модель, и xgboost окончательно получит коэффициенты этой линейной модели.
- dart: указывает на использование усилителя дротика.
без звука [по умолчанию 0]Когда значение этого параметра равно 1, включается беззвучный режим и никакая информация не выводится. Как правило, этот параметр по умолчанию имеет значение 0, потому что это может помочь нам лучше понять модель.
nthread[по умолчанию максимально возможное количество потоков]Этот параметр используется для управления многопоточностью и должен быть введен в число ядер в системе. Если вы хотите использовать все ядра ЦП, то не вводите этот параметр, алгоритм его автоматически обнаружит.
num_pbuffer Указывает размер буфера предсказания (этот буфер используется для сохранения результатов предсказания предыдущего шага повышения). Обычно устанавливается на количество обучающих выборок. Этот параметр автоматически устанавливается xgboost и не требует указания пользователем.
num_feature Количество признаков выборки. Обычно устанавливается на максимальный размер объекта. Этот параметр автоматически устанавливается xgboost и не требует указания пользователем.

Параметры усилителя дерева

Линейные ускорители используются редко, потому что древовидные ускорители намного превосходят линейные ускорители. Параметры бустера дерева (для booster=gbtree,dart):

эта [по умолчанию 3]Аналогично параметру скорости обучения в GBM. Уменьшая веса на каждом шаге, можно повысить надежность модели. Диапазон — [0,1], типичные значения — 0,01–0,2.
min_child_weight [по умолчанию 1]Порог веса для дочерних узлов. Он описывает следующее: для листового узла при его разделении порог суммы весов всех его дочерних узлов. Так называемый вес, для линейной модели (booster=gblinear) вес равен: количество выборок, содержащихся в листовом узле, для древовидной модели (booster=gbtree, dart) вес равен: листовой узел содержит сумма всех частных производных второго порядка выборок. Этот параметр используется, чтобы избежать переобучения. Когда его значение велико, это может помешать модели изучить локальные специальные выборки. Но если это значение слишком велико, это приведет к недообучению. Этот параметр необходимо настроить с помощью CV. Чем больше значение, тем более консервативен алгоритм (как можно меньше делений).
- Если сумма весов всех его дочерних узлов больше порогового значения, листовой узел стоит продолжать делить
- Если сумма весов всех его дочерних узлов меньше порога, листовой узел не стоит продолжать делить
max_delta_step [по умолчанию 0]Максимальный шаг дельты, когда веса оцениваются для каждого дерева. Диапазон значений $[0,\infty]$ , 0 означает отсутствие ограничений.
максимальная_глубина[по умолчанию 6]Параметры в GBM такие же, это значение и есть максимальная глубина дерева. Это значение также используется, чтобы избежать переобучения. Чем больше max_depth, тем более конкретные и локальные образцы будет изучать модель. Необходимо использовать функцию CV для настройки. Типичное значение: 3-10
max_leaf_nodes Наибольшее количество узлов или листьев на дереве. Может заменить роль max_depth. Потому что, если сгенерировано бинарное дерево, дерево глубины n будет генерировать не более n ^ 2 листьев. Если этот параметр определен, GBM игнорирует параметр max_depth.
гамма[по умолчанию 0]Также известен как минимальный сплит-лосс min_split_loss. Он описывает следующее: для листового узла при его разделении пороговое значение уменьшения функции потерь. Чем больше значение, тем более консервативен алгоритм (как можно меньше делений). Значение по умолчанию – 0.
- Если он больше порога, листовой узел стоит продолжать делить
- Если он меньше порога, листовой узел не стоит продолжать делить
max_delta_step[по умолчанию 0]Этот параметр ограничивает максимальный размер шага изменения веса для каждого дерева. Если значение этого параметра равно 0, это означает, что ограничений нет. Если ему придать некоторое положительное значение, то это сделает алгоритм более консервативным. Обычно этот параметр не нужно задавать. Но это очень полезно для логистической регрессии, когда выборки по категориям очень несбалансированы. Этот параметр обычно не используется, но вы можете найти для него другие применения.
подвыборка [по умолчанию 1]Коэффициент выборки обучающих выборок. Точно такой же, как параметр подвыборки в GBM. Этот параметр управляет долей случайной выборки для каждого дерева. Уменьшение значения этого параметра делает алгоритм более консервативным и позволяет избежать переобучения. Однако, если это значение установлено слишком маленьким, это может привести к недообучению. Типичное значение: 5-1
colsample_bytree[по умолчанию 1]Коэффициент выборки объектов при построении поддеревьев. Аналогично параметру max_features в GBM. Используется для управления пропорцией количества столбцов, выбранных случайным образом для каждого дерева (каждый столбец является функцией). Типичное значение: 5-1
colsample_bylevel[по умолчанию 1]Коэффициент выборки признаков при поиске точек разделения. Он используется для управления пропорцией выборки количества столбцов для каждого разделения каждого уровня дерева. Этот параметр обычно не используется, поскольку параметр subsample и параметр colsample_bytree могут играть одну и ту же роль. Если он равен 5, это означает, что половина функций используется случайным образом для поиска наилучшей точки разделения. Это помогает уменьшить переоснащение.
лямбда [по умолчанию 1]Член регуляризации L2 для весов. (Аналогично регрессии Риджа). Этот параметр используется для управления частью регуляризации XGBoost. Чем больше значение, тем проще модель.
альфа [по умолчанию 0]Член регуляризации L1 для весов. (Аналогично регрессии Лассо). Его можно применять к очень большим размерам, что делает алгоритм быстрее. Чем больше значение, тем проще модель.
scale_pos_weight [по умолчанию 1]Он используется для корректировки веса положительных и отрицательных образцов и часто используется в задачах классификации с дисбалансом классов. Типичное значение параметра: количество отрицательных образцов/количество положительных образцов.
tree_method [по умолчанию 'авто']Задает алгоритм построения дерева, который может принимать следующие значения (распределенная версия алгоритма и версия алгоритма с нехваткой памяти поддерживают только алгоритмы аппроксимации, такие как 'приблизительно', 'hist', 'gpu_hist'):
- 'auto': используйте эвристику, чтобы выбрать более быстрый метод tree_method:
  - Для малых и средних обучающих наборов разделяйте узлы с помощью точного жадного алгоритма.
  - Для очень больших обучающих наборов разделите узлы с помощью алгоритма аппроксимации.
  - Старая версия всегда использовала жадный алгоритм для разделения узлов на одной машине.
- «точный»: разделите узлы с использованием точного жадного алгоритма.
- 'приблизительно': разделить узлы с использованием алгоритма аппроксимации.
- 'hist': разделение узлов с использованием алгоритма аппроксимации, оптимизированного для гистограммы (например, с использованием оптимизации кэширования бинов)
- 'gpu_exact': точный жадный алгоритм на основе графического процессора для разделения узлов.
- 'gpu_hist': алгоритм гистограммы на основе графического процессора для разделения узлов.
sketch_eps [по умолчанию 03]Задает размер шага для группирования. Его диапазон значений составляет (0,1). Он используется только для tree_medhod='приблизительно'. Это даст примерно 1/sketch_eps сегментов. Он не отображает сегменты, но подсчитывает каждую единицу Sketch_pes (одна единица представляет собой интервал между максимальным значением и минимальным значением). Обычно пользователю не нужно настраивать этот параметр.
средство обновления [по умолчанию 'grow_colmaker, обрезка']Это строка с разделителями-запятыми, указывающая набор средств обновления дерева, которые необходимо запустить для построения и пересмотра дерева решений. Этот параметр обычно устанавливается автоматически и не требует указания пользователем. Но пользователь также может указать это явно.
refresh_leaf [по умолчанию 1]Это плагин для обновления. Если значение равно true, обновляются как статистика узлов дерева, так и данные конечных узлов дерева; в противном случае обновляются только статистические данные узлов дерева.
process_type Определяет выполняемую обработку (например: создать поддерево, обновить поддерево). Этот параметр обычно устанавливается автоматически и не требует указания пользователем.
Grow_policy [по умолчанию 'по глубине']Используется для указания стратегии роста поддерева. Поддерживается только tree_method='hist'. Есть две стратегии:
- «По глубине»: сначала разделите те дочерние узлы, которые находятся близко к корню.
- 'lossguide': отдать приоритет разделению дочернего элемента с самым быстрым уменьшением функции потерь.
max_leaves[по умолчанию 0]Самые листовые узлы. Если 0, ограничений нет. Этот параметр имеет отношение только к функцииrow_policy='lossguide'.
max_bin [по умолчанию 256]Указывается максимальное количество ковшей. Этот параметр действителен, только если tree_method='hist','gpu_hist'.
Предиктор [по умолчанию 'cpu_predictor']Укажите алгоритм предиктора, который может быть:
- 'cpu_predictor': использовать ЦП для прогнозирования
- 'gpu_predictor': использовать GPU для предсказания. Для tree_method='gpu_exact,gpu_hist' по умолчанию используется 'gpu_redictor'.

Параметры Dart Booster

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

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

Из-за введения случайности dart и gbtree различаются следующим образом:

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

Есть два основных различия между алгоритмом DART и алгоритмом MART (GBDT):

dropout

При расчете градиента, который будет соответствовать следующему дереву, просто случайным образом выберите часть деревьев, которые уже были сгенерированы. Предполагая, что текущая модель представляет собой M после n итераций, $M=\sum_{i=1}^nT_i$ ,среди T_i является i-м изученным деревом. Алгоритм DART сначала выбирает случайное подмножество $I\subset{\{1,…,n\}}$ , чтобы создать модель $\hat{M}=\sum_{i\in{I}}T_i$ . дерево Т из $\{(x,-L_x'(\hat{M}(x)))\}$ учиться, в L_x'() Указывает, что градиент функции потерь используется в качестве следующей метки, а градиент функции потерь используется в качестве входной метки следующего дерева в GDBT.

Нормализованный

Второе различие между DART и MART заключается в том, что когда DART добавляет дерево, его необходимо сначала нормализовать. Обоснование нормализации таково: дерево T — это попытка уменьшить $\hat{M}$ И разрыв между лучшим предиктором, выпавшими деревьями также должен сократить этот разрыв. Итак, представьте новые И дерево, и упавшие деревья служат одной и той же цели. Далее, предположим, что модель построена I $\hat{M}$ При сбрасывании k деревьев. Таким образом, новое дерево T примерно в k раз больше, чем каждое отдельное дерево в отброшенных деревьях. Следовательно, алгоритм DART умножает дерево T на 1/k, что делает размер T и каждого отброшенного экземпляра деревья одинаковые. Затем и новое дерево, и отброшенные деревья умножаются на k/(1+k), и новое дерево добавляется в модель ансамбля. Умножение на k/(k+1) гарантирует, что введение нового дерева будет иметь тот же эффект, что и его отсутствие.

Официальная документация XGBoost

Шаг m, предполагая, что K деревьев отбрасываются случайным образом, устанавливается индекс отброшенного дерева $\mathbb K$ . сделать $D=\sum_{k\in \mathbb K}h_k$ , m-е дерево. Тогда целевая функция:

$\mathcal L=\sum_{i=1}^NL\left(y_i,\hat y^{<m-1>}_i-D(\mathbf {\vec x}_i)+\nu h_m(\mathbf{\vec x}_i)\right)+\Omega(f_m)$

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

$f_m = \sum_{k\ne \mathbb K} h_k+\alpha\left(\sum_{k\in\mathbb K}h_k+b \nu h_m\right)$

где b — отношение веса нового поддерева к отброшенному поддереву, $\alpha$ является поправочным коэффициентом.
сделать $\hat M=\sum_{k\ne \mathbb K} h_k$ . Причина нормализации:пытаясь уменьшить $\hat M$ разрыв до ворот, и D также попытается сократить разрыв $\hat M$ в промежутке между мишенями. Если одновременно вводится случайно отброшенный набор поддеревьев D, а также новое поддерево, это приведет к перерегулированию.
Существует две стратегии нормализации:
- «дерево»: вновь добавленное поддерево имеет тот же вес, что и каждое отброшенное поддерево, при условии, что все $\frac 1K$ . В настоящее время $b=\frac 1K$ , то есть:

$\alpha\left(\sum_{k\in\mathbb K}h_k+b \nu h_m\right)=\alpha\left(\sum_{k\in\mathbb K}h_k+\frac \nu K h_m\right) \sim \alpha\left(1+\frac \nu K\right)D=\alpha \frac{K+\nu}{K}D$

Чтобы уменьшить перерегулирование, следует сделать $\alpha\left(\sum_{k\in\mathbb K}h_k+b \nu h_m\right) \sim D$ , то есть: $\alpha=\frac{K}{K+\nu}$ .

- «лес»: вес вновь добавленного поддерева равен сумме весов отброшенных поддеревьев. Предположим, что все веса отброшенных поддеревьев равны $\frac 1K$ , тогда b=1 в это время, тогда:

$\alpha\left(\sum_{k\in\mathbb K}h_k+b \nu h_m\right)=\alpha\left(\sum_{k\in\mathbb K}h_k+ \nu h_m\right) \sim \alpha\left(1+ \nu \right)D$

Чтобы уменьшить перерегулирование, следует сделать $\alpha\left(\sum_{k\in\mathbb K}h_k+b \nu h_m\right) \sim D$ , то есть $\alpha=\frac{1}{1+\nu}$ : .

Оригинальная ссылка:Рашми Корлакай Винаяк, Ран Гилад-Бахрах, «DART: Dropouts встречает деревья множественной аддитивной регрессии».

Бустер DART наследует gbtree, поэтому dart также имеет такие параметры, как eta.gamma, max_depth и т. д. Дополнительные параметры следующие:

sample_type[по умолчанию 'униформа']Указывает стратегию при отбрасывании:
- 'uniform': случайное удаление поддеревьев
- «взвешенный»: отбросить поддеревья в соответствии с пропорцией весов
normaliz_typeОн определяет стратегию нормализации:
- «дерево»: новое дерево имеет тот же вес, что и каждое отброшенное дерево, а новое поддерево будет масштабировано до: $\frac{1}{K+v}$ ; отброшенное поддерево масштабируется до $\frac{v}{K+v}$ . где v — скорость обучения, а K — количество отброшенных поддеревьев
- 'forest': новое дерево имеет тот же вес, что и сумма всех отброшенных деревьев, а новое поддерево будет масштабировано до: $\frac{1}{1+v}$ ; отброшенное поддерево масштабируется до $\frac{v}{1+v}$ . где v - скорость обучения
rate_drop [по умолчанию 0]Коэффициент отсева определяет долю текущих поддеревьев, которые будут отброшены во все текущие поддеревья. Диапазон: [0,1].
one_drop[по умолчанию 0]Если этот параметр имеет значение true, по крайней мере одно поддерево всегда удаляется при отбрасывании.
skip_drop [по умолчанию 0]Указывает вероятность невыполнения отсева в диапазоне [0,1].
- Если отсев пропущен, новое дерево добавляется в модель так же, как и gbtree.
- Ненулевой skip_drop имеет более высокий приоритет, чем rate_drop и one_drop.

Параметры линейного бустера

Лямбда [по умолчанию 0]Коэффициент регуляризации L2 (регуляризация на основе весов), чем больше значение, тем проще модель
Альфа [по умолчанию 0]Коэффициент регуляризации L1 (регуляризация по весам), чем больше значение, тем проще модель
lambda_bias [по умолчанию 0]Коэффициент регуляризации L2 (регуляризация на основе смещения), никакой регуляризации L1 на основе смещения, потому что это не имеет значения.

Параметры регрессии Твиди

weedie_variance_power [по умолчанию 5]Определяет дисперсию твиди-распределения. Диапазон значений (1,2), чем ближе к 1, тем ближе к распределению Пуассона, чем ближе к 2, тем ближе к гамма-распределению.

Целевые параметры обучения

Этот параметр используется для управления идеальной целью оптимизации и измерения результатов каждого шага.

цель[рег.по умолчанию:линейный]Укажите тип задачи
- 'reg:linear': модель линейной регрессии. Выход его модели имеет непрерывное значение
- 'reg:logistic': модель логистической регрессии. Выход его модели непрерывен в интервале [0,1].
- 'binary:logistic': Модель логистической регрессии бинарной классификации, ее выходные данные модели представляют собой непрерывное значение, расположенное в интервале [0,1], указывающее вероятность взятия положительных и отрицательных категорий. Он почти идентичен reg:logistic с одним отличием:
  - Метрикой оценки по умолчанию для reg:logistic является rmse .
  - Метрика оценки по умолчанию для «двоичного:логистика» — это ошибка.
- 'binary:logitraw': модель логистической регрессии для двоичной классификации, вывод в виде значения оценки (значение до логистического преобразования).
- 'count:poisson': пуассоновская регрессия по данным подсчета, результатом является среднее значение распределения Пуассона.
- 'multi:softmax': модель мультиклассификации на основе Softmax. На этом этапе вам нужно установить параметр num_class, чтобы указать количество классов. Возвращает предсказанный класс (не вероятность)
- 'multi:softprob': модель с несколькими классами, основанная на softmax, но ее вывод представляет собой матрицу: ndata*nclass, дающую вероятность того, что каждый образец принадлежит каждому классу.
- 'rank:pairwise': модель ранжирования (цель оптимизации - минимизировать попарные потери)
- 'reg:gamma': гамма-регрессия, результатом является среднее значение гамма-распределения.
- 'reg:tweedie': 'твиди-регрессия'.
base_score [по умолчанию 5]Начальная оценка прогноза для всех выборок, которая используется для установки начального глобального смещения. Когда количество итераций достаточно велико, этот параметр мало влияет.
eval_metric[Значение по умолчанию зависит от значения целевого параметра]Мера достоверных данных. Для задач регрессии по умолчанию используется значение rmse, а для задач классификации — ошибка. Значением по умолчанию для ранжирования задач является средняя средняя точность. Типичные значения:
- rmse среднеквадратическая ошибка
- может означать абсолютную ошибку
- logloss отрицательное значение функции логарифмического правдоподобия
- частота ошибок бинарной классификации ошибок (пороговое значение равно 5), вычисляет: количество ошибочно предсказанных отсчетов / количество всех отсчетов
- error@t Частота ошибок для двоичной классификации. Но его порог больше не равен 5, а задается строкой t (это численно преобразованная строка)
- merror мультиклассовая частота ошибок, вычисляет: количество неверных выборок/количество всех выборок
- Функция отрицательного логарифмического правдоподобия mlogloss для многоклассовой классификации
- функция потерь auc площадь auc под кривой
- ndcg Нормализованная дисконтированная кумулятивная оценка прироста
- карта Средний балл точности
- ndcg@n,map@n n — целое число, используемое для разделения лучших выборок проверочного набора для оценки.
- ndcg-,map-,ndcg@n-,map@n- NDCG и MAP оценят оценку списка без каких-либо положительных образцов как 1. При добавлении «-» в метрике оценки XGBoost оценит эту оценку как 0, чтобы быть последователен при некоторых условиях. неоднократно
- poisson-nloglik Для регрессии Пуассона используйте отрицательное логарифмическое правдоподобие
- gamma-nloglik Для гамма-регрессии используйте отрицательное логарифмическое правдоподобие
- gamma-deviance Для гамма-регрессии используйте дисперсию остатков
- tweedie-nloglik: для твиди-регрессии используйте отрицательное логарифмическое правдоподобие
Семя [по умолчанию 0]Начальное число случайных чисел, которое можно задать для воспроизведения результатов случайных данных, а также можно использовать для настройки параметров.

Если вы раньше использовали Scikit-learn, возможно, вы не знакомы с этими параметрами. Но есть и хорошие новости: есть пакет sklearn для модуля Python XGBoost. Параметры в этом пакете названы в стиле sklearn. Имя функции, которое изменится:

eta ->learning_rate
lambda->reg_lambda
alpha->reg_alpha

Вам должно быть интересно, почему мы не ввели параметр, аналогичный «n_estimators» в GBM. В XGBoost действительно есть аналогичный параметр, который передается как параметр num_boosting_rounds при вызове функции подгонки в стандартной реализации XGBoost.

Ссылка на ссылку:

GitHub.com/Лифт Чен/Литтл Армс…

вычисление вне памяти

Для вычислений во внешней памяти и в памяти разница между ними невелика. За исключением разницы в имени файла.

Имя файла в памяти: имя файла
Имя файла внешней памяти: filename#cacheprefix.
- имя файла: это путь к набору данных, который вы хотите загрузить (в настоящее время поддерживаются только файлы в формате libsvm)
- cacheprefix: Путь к указанному файлу кэша. xgboost будет использовать его для кеша внешней памяти. Например: dtrain = xgb.DMatrix('../data/my_data.txt.train#train_cache.cache'), тогда вы обнаружите, что xgboost создаст файл my_cache.cache в местоположении txt.
Рекомендуется установить nthread равным количеству реальных процессоров. Современные процессоры поддерживают гиперпоточность, например, 4 ядра и 8 потоков. На данный момент nthread установлен на 4 вместо 8.
Для распределенных вычислений метод задания имени файла для вычислений во внешней памяти также одинаков: data = «hdfs:///path-to-data/my_data.txt.train#train_cache.cache»

GPU-вычисления

xgboost поддерживает вычисления на графическом процессоре при условии, что поддержка графического процессора включена во время установки. Чтобы использовать обучение GPU, укажите для параметра tree_method следующие значения:

'gpu_exact': стандартный алгоритм xgboost. Он выполняет точный поиск для каждой точки разделения. По сравнению с gpu_hist обучается медленнее и использует больше памяти.
'gpu_hist': использовать алгоритм аппроксимации гистограммы xgboost. Он обучается быстрее и занимает меньше памяти

Когда tree_method имеет значение «gpu_exact», «gpu_hist», прогноз модели по умолчанию использует ускорение графического процессора.

Вы можете указать вычислительное устройство при прогнозировании, установив параметр прогнозирования:

'cpu_predictor': использовать ЦП для выполнения прогнозов модели.
'gpu_predictor': использовать GPU для прогнозирования модели.

Несколько графических процессоров можно использовать в сочетании с параметромrow_gpu_hist и параметром n_gpus. Если для n_gpus установлено значение -1, используются все графические процессоры. По умолчанию это 1. Несколько графических процессоров не обязательно быстрее, чем один графический процессор, из-за ограничений пропускной способности шины PCI скорость передачи данных может стать узким местом. Устройство можно выбрать через параметр gpu_id, который по умолчанию равен 0. Если не ноль, правило нумерации GPU: mod(gpu_id + i) % n_visible_devices для i в 0~n_gpus-1

Параметры, поддерживаемые вычислениями на GPU:

Монотонное ограничение

В модели могут быть некоторые монотонные ограничения: когда $x \le x^\prime$ Время:

как $f(x_1,x_2,\cdots,x,\cdots,x_{n}) \le f(x_1,x_2,\cdots,x^\prime,\cdots,x_{n})$ , ограничение называется монотонно возрастающим ограничением
как $f(x_1,x_2,\cdots,x,\cdots,x_{n}) \ge f(x_1,x_2,\cdots,x^\prime,\cdots,x_{n})$ ограничение называется монотонно убывающим ограничением

Если вы хотите добавить монотонные ограничения в xgboost, вы можете установить параметр monotone_constraints. Предполагая, что образец имеет 2 функции, тогда:

params['monotone_constraints'] = "(1,-1)": указывает, что первая функция монотонно увеличивается, вторая функция монотонно уменьшается.
params['monotone_constraints'] = "(1,0)" : указывает, что первая функция монотонно увеличивается, вторая функция не имеет ограничений
params['monotone_constraints'] = "(1,1)": указывает, что первая функция монотонно увеличивается; вторая функция монотонно увеличивается

1 справа представляет монотонно возрастающее ограничение, 0 — отсутствие ограничения, -1 — монотонно убывающее ограничение. Количество признаков соответствует количеству значений.

Интерфейс данных XGBoost

Формат данных

Данные xgboost хранятся в объектах DMatrix, а xgboost поддерживает загрузку данных непосредственно из файлов в следующих форматах:

libsvm в текстовом формате. Его формат:

 [label] [index1]:[value1] [index2]:[value2] ...
 [label] [index1]:[value1] [index2]:[value2] ...
 ...

Двоичный буферный файл xgboost

dtrain = xgb.DMatrix('train.svm.txt') #libsvm 格式
dtest = xgb.DMatrix('test.svm.buffer') # xgboost binary buffer 文件

Загрузить данные в массив 2D numpy

data = np.random.rand(5, 10)  
label = np.random.randint(2, size=5) 
dtrain = xgb.DMatrix(data, label=label)#从 numpy array 中加载

Загрузить данные в разреженный массив

csr = scipy.sparse.csr_matrix((dat, (row, col)))
dtrain = xgb.DMatrix(csr)

DMatrix

DMatrix: структура данных, используемая внутри xgboost, которая хранит наборы данных и оптимизирована для потребления памяти и скорости обучения.

xgboost.DMatrix(data, label=None, missing=None, weight=None, silent=False, 
     feature_names=None, feature_types=None, nthread=None)

параметр:

data: представляет набор данных. Возможно:
- Строка, представляющая имя файла. данные загружаются из этого файла
- Двумерный массив numpy, представляющий набор данных.
label: последовательность, представляющая образцы меток.
пропущено: значение, которое является значением по умолчанию для отсутствующих значений.
вес: последовательность, указывающая вес каждой выборки в наборе данных.
молчание: логическое значение. Если True, промежуточная информация не выводится.
feature_names: последовательность строк, задающая имя каждой функции
feature_types: последовательность строк, указывающая тип данных каждой функции.
nthread: количество потоков

Атрибуты:

feature_names: возвращает имена каждой функции
feature_types: возвращает тип данных каждой функции.

метод:

.get_base_margin(): возвращает число с плавающей запятой, представляющее базовое поле DMatrix.
.set_base_margin(margin): установите базовое поле DMatrix. Параметры: поле, t Последовательность, которая дает предел предсказания для каждой выборки.
.get_float_info(field): возвращает пустой массив, представляющий свойство float DMatrix.
.set_float_info(поле,данные): установите свойство float DMatrix.
.set_float_info_npy2d (поле, данные): установите свойство float DMatrix. Здесь данные представляют собой параметр двумерного массива numpy:
- поле: Строка, задающая имя поля информации. Примечание: Значение неизвестно.
- data: массив numpy, дающий информацию с плавающей запятой для каждой точки в наборе данных
.get_uint_info(поле): возвращает целочисленное свойство DMatrix без знака.
.set_unit_info(поле,данные): Установите целочисленное свойство DMatrix без знака. Возвращаемое значение: массив numpy, представляющий целочисленную информацию без знака набора данных.
.get_label(): возвращает пустой массив, представляющий метку DMatrix.
.set_label(label): Установите метку образца.
.set_label_npy2d(label): установите метку образца. Метка здесь представляет собой двумерный массив numpy. Параметры: метка: последовательность, представляющая метку образца.
.get_weight(): пустой массив, который возвращает выборочные веса DMatrix.
.set_weight(вес): установите вес образца.
.set_weight_npy2d(weight): Установите вес выборки. Вес здесь представляет собой двумерный массив numpy
.num_col(): возвращает количество столбцов DMatrix, возвращаемое значение: целое число, представляющее количество функций.
.num_row(): возвращает количество строк в DMatrix, возвращаемое значение: целое число, представляющее количество выборок.
save_binary(fname,silent=True): сохраните DMatrix в файл буфера xgboost. параметр:
- fname: строка, представляющая имя выходного файла
- молчание: логическое значение. Если True, промежуточная информация не выводится.
.set_group(group): Установить размер каждой группы в DMatrix (для задач сортировки) Параметры: group: Последовательность, указывающая размер каждой группы
slice(rindex): разрезает DMaxtrix и возвращает новый DMaxtrix. Новый DMatrix содержит только rindex
- Параметры: rindex: список, содержащий индекс, который необходимо сохранить.
- Возвращаемое значение: новый объект DMatrix.

Пример:

data/train.svm.txt 的内容：
 
1 1:1 2:2
1 1:2 2:3
1 1:3 2:4
1 1:4 2:5
0 1:5 2:6
0 1:6 2:7
0 1:7 2:8
0 1:8 2:9

Тестовый код:

import xgboost as xgt
import numpy as np
 
 
class MatrixTest:
    '''
    测试 DMatrix
    '''
 
    def __init__(self):
        self._matrix1 = xgt.DMatrix('data/train.svm.txt')
        self._matrix2 = xgt.DMatrix(data=np.arange(0, 12).reshape((4, 3)),
                                    label=[1, 2, 3, 4], weight=[0.5, 0.4, 0.3, 0.2],
                                    silent=False, feature_names=['a', 'b', 'c'],
                                    feature_types=['int', 'int', 'float'], nthread=2)
 
    def print(self, matrix):
        print('feature_names:%s' % matrix.feature_names)
        print('feature_types:%s' % matrix.feature_types)
 
    def run_get(self, matrix):
        print('get_base_margin():', matrix.get_base_margin())
        print('get_label():', matrix.get_label())
        print('get_weight():', matrix.get_weight())
        print('num_col():', matrix.num_col())
        print('num_row():', matrix.num_row())
 
    def test(self):
        print('查看 matrix1 :')
        self.print(self._matrix1)
        # feature_names:['f0', 'f1', 'f2']
        # feature_types:None
 
        print('\n查看 matrix2 :')
        self.print(self._matrix2)
        # feature_names:['a', 'b', 'c']
        # feature_types:['int', 'int', 'float']
 
        print('\n查看 matrix1 get:')
        self.run_get(self._matrix1)
        # get_base_margin(): []
        # get_label(): [1. 1. 1. 1. 0. 0. 0. 0.]
        # get_weight(): []
        # num_col(): 3
        # num_row(): 8
 
        print('\n查看 matrix2 get:')
        self.run_get(self._matrix2)
        # get_base_margin(): []
        # get_label(): [1. 2. 3. 4.]
        # get_weight(): [0.5 0.4 0.3 0.2]
        # num_col(): 3
        # num_row(): 4
 
        print(self._matrix2.slice([0, 1]).get_label())
        # [1. 2.]

Интерфейс модели XGBoost

Booster

Booster — это модель xgboost, которая включает базовую реализацию таких задач, как обучение, прогнозирование и оценка.

xbgoost.Booster(params=None,cache=(),model_file=None)

параметр:

params: Словарь с параметрами модели. Booster вызовет метод set_param(params) для установки параметров модели.
cache: список с кэшированными элементами. Объект, элементами которого являются DMatrix. Модель считывает имя и тип функции из этих объектов DMatrix (требуется, чтобы эти объекты DMatrix имели одинаковое имя и тип функции).
model_file: строка, указывающая расположение файла модели. Если указан файл model_file, вызывается load_model(model_file) для загрузки модели.

Свойства: доступ и установка свойств с помощью методов.

метод:

.attr(key): Получить атрибуты бустера. Если атрибут не существует, вернуть None Параметры: ключ: строка, представляющая имя атрибута, который необходимо получить.
.set_attr(**kwargs): установить атрибуты бустера. Параметры: kwargs: ключевые аргументы. Примечание. В настоящее время значения параметров поддерживают только строки. Если значение параметра равно None, это означает, что параметр удален.
.attributes(): возвращает атрибуты бустера в виде словаря.
.set_param(params,value=None): Установите параметры бустера. параметр:
- params: список (элементы представляют собой пары ключ-значение), словарь или строка. Указывает параметр, который необходимо установить;
- значение: если params — это строка, то params — это ключ, а value — это значение параметра.
.boost(dtrain,grad,hess): выполнить одну итерацию обучения. параметр:
- dtrain: объект DMatrix, представляющий тренировочный набор
- grad: список, представляющий градиент первого порядка
- hess: список, представляющий частные производные второго порядка
.update(dtrain,iteration,fobj=None): обновить итерацию. параметр:
- dtrain: объект DMatrix, представляющий тренировочный набор
- iteration: целое число, представляющее текущий номер шага итерации.
- fobj: функция, представляющая пользовательскую целевую функцию. Поскольку у Booster нет метода .train(), ему необходимо выполнять итерацию со следующей стратегией:

for i in range(0,100):
    booster.update(train_matrix,iteration=i)

.copy(): копирует текущий бустер и возвращает новый объект Booster.
.dump_model(fout,fmap=",with_stats=False): дамп модели в текстовый файл.Параметры:
- fout: строка, представляющая имя выходного файла;
- fmap: строка, представляющая имя файла, в котором хранится карта объектов. Бустер должен прочитать из него информацию об объекте. Каждая строка файла по очереди представляет объект. Формат каждой строки следующий: имя объекта:тип объекта, где тип объекта — это строка, представляющая тип данных, например, int, float ;
- with_stats: логическое значение. Если True, вывести статистику разделения.
.get_dump(fmap=”,with_stats=False,dump_format='text'): модель дампа представляет собой список символов (вместо сохранения в файл).Параметры: dump_format: строка, задающая формат вывода.Возвращаемое значение. : список строк.Каждая строка описывает поддерево.
.eval(data,name='eval',iteration=0): оценить модель. Возвращаемое значение: строка, представляющая параметр результата оценки:
- data: объект DMatrix, представляющий набор данных
- name: строка, представляющая имя набора данных
- iteration: целое число, представляющее текущий номер итерации
.eval_set(evals,iteration=0,feval=None): оценка серии наборов данных. Возвращаемое значение: строка, представляющая результат оценки. параметр:
- evals: список кортежей (DMatrix, строка), дающих набор данных для оценки
- iteration: целое число, представляющее текущий номер итерации
- feval: функция, которая дает пользовательскую функцию оценки
.get_fscore(fmap="): возвращает важность каждой функции. Ускоритель должен прочитать информацию об этой функции. Возвращаемое значение: словарь, в котором указывается важность каждой функции.
.get_score(fmap=»,importance_type='weight'): возвращает важность каждой функции. Возвращаемое значение: словарь, указывающий важность каждой функции. Параметры: Important_type: строка, указывающая метрику функции. Это может быть:
- «вес»: в настоящее время мерой важности признака является: общее количество раз, когда признак используется для разделения набора данных во всех деревьях.
- «прирост»: в настоящее время мерой важности функции является: средний прирост, полученный функцией в «покрытии» дерева.
.get_split_value_histogram(feature,fmap="",bins=None,as_pandas=True): получить гистограмму значений деления функции. Возвращаемое значение: результат гистограммы, представляющий точки разделения, возвращенные в виде numpy ndarray или DataFrame.Параметры:
- feature: строка, задающая имя функции секционирования
- fmap: строка, содержащая имя файла карты объектов. Бустеру необходимо считывать с него информацию о функциях.
- bins: максимальное количество бинов. Если bins=None или bins>n_unique, количество сегментов фактически равно n_unique. где n_unique — уникальный из значений, разделяющих точки
- as_pandas : логическое значение. Если True, возвращает DataFrame; в противном случае возвращает пустой ndarray.
.load_model(fname): загрузить модель из файла. Параметры: fname: файл или буфер памяти, из которого xgboost загружает модель
.save_model(fname): сохранить модель в файл. Параметры: fname: строка, представляющая имя файла.
save_raw(): сохранить модель как буфер памяти. Возвращаемое значение: буфер памяти, представляющий модель
.load_rabit_checkpoint(): Инициализировать модель из контрольной точки Rabit. Возвращаемое значение: целое число, представляющее номер версии модели.
.predict (данные, output_margin = False, ntree_limit = 0, pred_leaf = False, pred_contribs = False, приблизительно_contribs = False): выполнить прогноз. Этот метод не является потокобезопасным. Для каждого бустера вы можете вызывать только его метод .predict в потоке. Если вы вызываете метод .predict в нескольких потоках, может возникнуть проблема. Чтобы решить эту проблему, вы должны вызвать функцию copy() в каждом потоке, чтобы скопировать бустер в каждый поток. Возвращаемое значение: ndarray, представляющий результат прогнозирования. параметр:
- data: объект DMatrix, представляющий тестовый набор
- output_margin: логическое значение. Указывает, следует ли выводить исходное непреобразованное значение поля.
- ntree_limit: целое число. Указывает, сколько поддеревьев использовать для предсказания. Значение по умолчанию равно 0, что означает использование всех поддеревьев. Вы можете использовать best_ntree_limit, если во время обучения происходит ранняя остановка.
- pred_leaf: логическое значение. Если True, будет выведено, на каком листе каждого поддерева находится каждая выборка. Это матрица nsample x ntrees. Листовые узлы каждого поддерева нумеруются от 1.
- pred_contribs: логическое значение. Если True, выведите вклад каждой функции в результат прогнозирования каждой выборки. Это матрица nsample x (nfeature+1). Причина добавления 1 связана с фактором смещения. Это в последней колонке. Сумма всех вкладов выборки является конечным результатом выборки.
- приблизительно_contribs: логическое значение. Если True, приблизительно оценивается вклад каждой функции.

Booster не имеет метода поезда. Итак, есть две стратегии получения обученного бустера.

Получите его из файла обученной модели.load_model()
Несколько вызовов метода .update()

Пример:

import xgboost as xgt
import pandas as pd
from sklearn.model_selection import train_test_split
 
_label_map = {
    # 'Iris-setosa':0, #经过裁剪的，去掉了 iris 中的 setosa 类
    'Iris-versicolor': 0,
    'Iris-virginica': 1
}
 
 
class BoosterTest:
    '''
    测试 Booster
    '''
 
    def __init__(self):
        df = pd.read_csv('./data/iris.csv')
        _feature_names = ['Sepal Length', 'Sepal Width', 'Petal Length', 'Petal Width']
        x = df[_feature_names]
        y = df['Class'].map(lambda x: _label_map[x])
 
        train_X, test_X, train_Y, test_Y = train_test_split(x, y,
                                                            test_size=0.3, stratify=y, shuffle=True, random_state=1)
        self._train_matrix = xgt.DMatrix(data=train_X, label=train_Y,
                                         eature_names=_feature_names,
                                         feature_types=['float', 'float', 'float', 'float'])
        self._validate_matrix = xgt.DMatrix(data=test_X, label=test_Y,
                                            feature_names=_feature_names,
                                            feature_types=['float', 'float', 'float', 'float'])
        self._booster = xgt.Booster(params={
            'booster': 'gbtree',
            'silent': 0,  # 打印消息
            'eta': 0.1,  # 学习率
            'max_depth': 5,
            'tree_method': 'exact',
            'objective': 'binary:logistic',
            'eval_metric': 'auc',
            'seed': 321},
            cache=[self._train_matrix, self._validate_matrix])
 
    def test_attribute(self):
        '''
        测试属性的设置和获取
        :return:
        '''
        self._booster.set_attr(key1='1')
        print('attr:key1 -> ', self._booster.attr('key1'))
        print('attr:key2 -> ', self._booster.attr('key2'))
        print('attributes -> ', self._booster.attributes())
 
    def test_dump_model(self):
        '''
        测试 dump 模型
        :return:
        '''
        _dump_str = self._booster.get_dump(fmap='model/booster.feature',
                                           with_stats=True, dump_format='text')
        print('dump:', _dump_str[0][:20] + '...' if _dump_str else [])
        self._booster.dump_model('model/booster.model',
                                 fmap='model/booster.feature', with_stats=True)
 
    def test_train(self):
        '''
        训练
        :return:
        '''
        for i in range(0, 100):
            self._booster.update(self._train_matrix, iteration=i)
            print(self._booster.eval(self._train_matrix, name='train', iteration=i))
            print(self._booster.eval(self._validate_matrix, name='eval', iteration=i))
 
    def test_importance(self):
        '''
        测试特征重要性
        :return:
        '''
        print('fscore:', self._booster.get_fscore('model/booster.feature'))
        print('score.weight:', self._booster.get_score(importance_type='weight'))
        print('score.gain:', self._booster.get_score(importance_type='gain'))
 
    def test(self):
        self.test_attribute()
        # attr:key1 ->  1
        # attr:key2 ->  None
        # attributes ->  {'key1': '1'}
        self.test_dump_model()
        # dump: []
        self.test_train()
        # [0]   train-auc:0.980816
        # [0]   eval-auc:0.933333
        # ...
        # [99]  train-auc:0.998367
        # [99]  eval-auc:0.995556
        self.test_dump_model()
        # dump: 0:[f2<4.85] yes=1,no...
        self.test_importance()
        # score: {'f2': 80, 'f3': 72, 'f0': 6, 'f1': 5}
        # score.weight: {'Petal Length': 80, 'Petal Width': 72, 'Sepal Length': 6, 'Sepal Width': 5}
        # score.gain: {'Petal Length': 3.6525380337500004, 'Petal Width': 2.2072901486111114, 'Sepal Length': 0.06247816666666667, 'Sepal Width': 0.09243024}
 
 
if __name__ == '__main__':
    BoosterTest().test()

прямое обучение

xgboost.train(): обучить бустер с заданными параметрами

xgboost.train(params, dtrain, num_boost_round=10, evals=(), obj=None, feval=None,
   maximize=False, early_stopping_rounds=None, evals_result=None, verbose_eval=True,
   xgb_model=None, callbacks=None, learning_rates=None)

параметр:

params: список (элементы представляют собой пары ключ-значение), словарь, представляющий параметры обучения
dtrain: объект DMatrix, представляющий тренировочный набор
num_boost_round: целое число, представляющее количество итераций повышения
evals: Список, элементами которого являются (DMatrix,string). Он дает набор проверки во время обучения и имя набора проверки (таким образом различая результаты оценки в наборе проверки).
obj: функция, представляющая пользовательскую целевую функцию.
feval: функция, представляющая пользовательскую функцию оценки
максимизировать: логическое значение. Если это True, то это означает, что нужно найти максимальное значение feval, в противном случае, это должно найти минимальное значение.
Early_stopping_rounds: целое число, представляющее параметр ранней остановки. Обучение останавливается, если ошибка проверки в наборе проверки не исчезает в течение итераций Early_stopping_rounds. Этот параметр требует, чтобы параметр evals содержал по крайней мере один набор проверки. Если параметр evals содержит несколько наборов проверки, используется последний из них. Возвращаемая модель — это модель из последней итерации (не лучшая модель). Если происходит ранняя остановка, модель имеет три дополнительных поля:
- .best_score: лучший результат
- .best_iteration: лучшее количество шагов итерации
- .best_ntree_limit: лучшее количество подмоделей
evals_result: словарь, содержащий метрики, которые необходимо оценить в тестовом наборе.
verbose_eval: логическое значение или целое число. Если True, метрика оценки будет печататься на каждом этапе повышения. Если целое число, метрика оценки будет печататься на каждом этапе повышения verbose_eval. Кроме того, будет распечатана оценочная метрика последнего этапа повышения, а также этапа повышения с ранней остановкой.
Learning_rates: список, указывающий скорость обучения для каждого шага итерации. Вы можете позволить скорости обучения снижаться.
xgb_model: экземпляр Booster или имя файла, в котором хранится модель xgboost. Это дает модель для обучения. Эта практика позволяет непрерывно тренироваться.
обратные вызовы: список функций обратного вызова, задающий эти функции для вызова после каждой итерации. Вы можете использовать некоторые функции обратного вызова, предопределенные в xgboost (расположенные в модуле обратного вызова). Например: xgboost.reset_learning_rate(custom_rates)

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

xgboost.cv(): выполняет перекрестную проверку с заданными параметрами. Часто используется как параметрический поиск.

xgboost.cv(params, dtrain, num_boost_round=10, nfold=3, stratified=False, folds=None,
     metrics=(), obj=None, feval=None, maximize=False, early_stopping_rounds=None,
     fpreproc=None, as_pandas=True, verbose_eval=None, show_stdv=True, seed=0,
     callbacks=None, shuffle=True)

параметр:

params: список (элементы представляют собой пары ключ-значение), словарь, представляющий параметры обучения
dtrain: объект DMatrix, представляющий тренировочный набор
num_boost_round: целое число, представляющее количество итераций повышения
nfold: целое число, представляющее количество перекрестно проверенных сгибов
стратифицированный: логическое значение. Если True, выполните стратифицированную выборку
folds: Экземпляр KFold, изученный в рамках scikit, или экземпляр StratifiedKFold.
метрики: строка или список строк, указывающих метрики оценки для перекрестной проверки. Если в параметрах также указано значение eval_metric, параметр metrics имеет приоритет.
obj: функция, представляющая пользовательскую целевую функцию.
feval: функция, представляющая пользовательскую функцию оценки
максимизировать: логическое значение. Если это True, то это означает, что нужно найти максимальное значение feval, в противном случае, это должно найти минимальное значение.
Early_stopping_rounds: целое число, представляющее параметр ранней остановки. Обучение останавливается, если ошибка проверки в наборе проверки не исчезает в течение итераций Early_stopping_rounds. Возвращает последний элемент в истории оценки. Результат — результат оценки наилучшего шага итерации.
fpreproc: функция. Это функция предварительной обработки, ее параметры (dtrain, dtest, param), а возвращаемое значение — это преобразованное значение (dtrain, dtest, param).
as_pandas: логическое значение. Возвращает DataFrame, если True, иначе возвращает numpy.ndarray
verbose_eval: обратиться к train()
show_stdv: логическое значение. Следует ли печатать подробное стандартное отклонение. Это не влияет на возвращаемый результат. Возвращаемый результат всегда включает стандартное отклонение.
seed: целое число, представляющее начальное число случайного числа
обратные вызовы: обратитесь к train()
shuffle: логическое значение. Если True, перемешайте данные перед созданием сгибов.

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

Пример:

import xgboost as xgt
import pandas as pd
from sklearn.model_selection import train_test_split
 
_label_map = {
    # 'Iris-setosa':0, #经过裁剪的，去掉了 iris 中的 setosa 类
    'Iris-versicolor': 0,
    'Iris-virginica': 1
}
 
 
class TrainTest:
    def __init__(self):
        df = pd.read_csv('./data/iris.csv')
        _feature_names = ['Sepal Length', 'Sepal Width', 'Petal Length', 'Petal Width']
        x = df[_feature_names]
        y = df['Class'].map(lambda x: _label_map[x])
        train_X, test_X, train_Y, test_Y = train_test_split(x, y, test_size=0.3,
                                                            stratify=y, shuffle=True, random_state=1)
        self._train_matrix = xgt.DMatrix(data=train_X, label=train_Y,
                                         feature_names=_feature_names,
                                         feature_types=['float', 'float', 'float', 'float'])
        self._validate_matrix = xgt.DMatrix(data=test_X, label=test_Y,
                                            feature_names=_feature_names,
                                            feature_types=['float', 'float', 'float', 'float'])
 
    def train_test(self):
        params = {
            'booster': 'gbtree',
            'eta': 0.01,
            'max_depth': 5,
            'tree_method': 'exact',
            'objective': 'binary:logistic',
            'eval_metric': ['logloss', 'error', 'auc']
        }
        eval_rst = {}
        booster = xgt.train(params, self._train_matrix, num_boost_round=20,
                            evals=([(self._train_matrix, 'valid1'), (self._validate_matrix, 'valid2')]),
                            early_stopping_rounds=5, evals_result=eval_rst, verbose_eval=True)
        ## 训练输出
        # Multiple eval metrics have been passed: 'valid2-auc' will be used for early stopping.
        # Will train until valid2-auc hasn't improved in 5 rounds.
        # [0]   valid1-logloss:0.685684 valid1-error:0.042857   valid1-auc:0.980816 valid2-logloss:0.685749 valid2-error:0.066667   valid2-auc:0.933333
        # ...
        # Stopping. Best iteration:
        # [1]   valid1-logloss:0.678149 valid1-error:0.042857   valid1-auc:0.99551  valid2-logloss:0.677882 valid2-error:0.066667   valid2-auc:0.966667
 
        print('booster attributes:', booster.attributes())
        # booster attributes: {'best_iteration': '1', 'best_msg': '[1]\tvalid1-logloss:0.678149\tvalid1-error:0.042857\tvalid1-auc:0.99551\tvalid2-logloss:0.677882\tvalid2-error:0.066667\tvalid2-auc:0.966667', 'best_score': '0.966667'}
 
        print('fscore:', booster.get_fscore())
        # fscore: {'Petal Length': 8, 'Petal Width': 7}
 
        print('eval_rst:', eval_rst)
        # eval_rst: {'valid1': {'logloss': [0.685684, 0.678149, 0.671075, 0.663787, 0.656948, 0.649895], 'error': [0.042857, 0.042857, 0.042857, 0.042857, 0.042857, 0.042857], 'auc': [0.980816, 0.99551, 0.99551, 0.99551, 0.99551, 0.99551]}, 'valid2': {'logloss': [0.685749, 0.677882, 0.670747, 0.663147, 0.656263, 0.648916], 'error': [0.066667, 0.066667, 0.066667, 0.066667, 0.066667, 0.066667], 'auc': [0.933333, 0.966667, 0.966667, 0.966667, 0.966667, 0.966667]}}
 
    def cv_test(self):
        params = {
            'booster': 'gbtree',
            'eta': 0.01,
            'max_depth': 5,
            'tree_method': 'exact',
            'objective': 'binary:logistic',
            'eval_metric': ['logloss', 'error', 'auc']
        }
 
        eval_history = xgt.cv(params, self._train_matrix, num_boost_round=20,
                              nfold=3, stratified=True, metrics=['error', 'auc'],
                              early_stopping_rounds=5, verbose_eval=True, shuffle=True)
        ## 训练输出
        # [0]   train-auc:0.974306+0.00309697   train-error:0.0428743+0.0177703 test-auc:0.887626+0.0695933 test-error:0.112374+0.0695933
        # ....
        print('eval_history:', eval_history)
        # eval_history:    test-auc-mean  test-auc-std  test-error-mean  test-error-std  \
        # 0       0.887626      0.069593         0.112374        0.069593
        # 1       0.925821      0.020752         0.112374        0.069593
        # 2       0.925821      0.020752         0.098485        0.050631
 
        # train-auc-mean  train-auc-std  train-error-mean  train-error-std
        # 0        0.974306       0.003097          0.042874          0.01777
        # 1        0.987893       0.012337          0.042874          0.01777
        # 2        0.986735       0.011871          0.042874          0.01777

Scikit-Learn API

xgboost предоставляет API для интерфейса scikit-learn.

xgboost.XGBRegressor: реализует API модели регрессии scikit-learn.

class xgboost.XGBRegressor(max_depth=3, learning_rate=0.1, n_estimators=100, 
     silent=True, objective='reg:linear', booster='gbtree', n_jobs=1, nthread=None, 
     gamma=0, min_child_weight=1, max_delta_step=0, subsample=1, colsample_bytree=1,
     colsample_bylevel=1, reg_alpha=0, reg_lambda=1, scale_pos_weight=1, 
     base_score=0.5, random_state=0, seed=None, missing=None, **kwargs)

параметр:

max_depth: целое число, представляющее максимальную глубину поддерева
Learning_rate: число с плавающей запятой, представляющее скорость обучения
n_estimators: целое число, представляющее количество поддеревьев, которые, как ожидается, будут изучены.
молчание: логическое значение. Если False, вывести промежуточную информацию
цель: строка или вызываемый объект, определяющий целевую функцию. Его сигнатура функции: target(y_true,y_pred) -> gra,hess. в:
- y_true: последовательность формы [n_sample], представляющая истинные значения метки.
- y_pred: последовательность формы [n_sample], представляющая предсказанное значение метки.
- grad: последовательность формы [n_sample], представляющая градиент для каждого образца.
- hess: последовательность формы [n_sample], представляющая вторую частную производную в каждой выборке
усилитель: строка. Указывает, какую базовую модель использовать. Может быть: 'gbtree', 'gblinear', 'dart'
n_jobs: целое число, указывающее степень параллелизма, то есть количество потоков, открываемых для обучения. Если -1, использовать все ЦП
гамма: число с плавающей запятой, также известное как min_split_loss. Он описывает следующее: для листового узла при его разделении пороговое значение уменьшения функции потерь.
min_child_weight: целое число, порог веса дочернего узла. Он описывает следующее: для листового узла при его разделении порог суммы весов всех его дочерних узлов.
max_delta_step: целое число, максимальный шаг дельты для оценки веса каждого дерева. Диапазон значений: 0 означает отсутствие ограничений, значение по умолчанию — 0 .
подвыборка: число с плавающей запятой, коэффициент выборки обучающих выборок. Диапазон значений — (0,1], а значение по умолчанию — 1. Если оно равно 5, это означает, что половина обучающих выборок используется для обучения поддерева случайным образом. Это помогает уменьшить переоснащение.
colsample_bytree: число с плавающей запятой, коэффициент выборки объектов при построении поддерева. Диапазон значений — (0,1], а значение по умолчанию — 1. Если оно равно 5, это означает, что половина функций используется для обучения поддерева случайным образом. Это помогает уменьшить переоснащение.
colsample_bylevel: число с плавающей запятой, коэффициент выборки признака при поиске разделительных точек. Диапазон значений — (0,1], а значение по умолчанию — 1. Если оно равно 5, это означает, что половина функций используется случайным образом для поиска наилучшей точки разделения. Это помогает уменьшить переоснащение.
reg_alpha: число с плавающей запятой, которое является коэффициентом регуляризации L1. это альфа-параметр xgb
reg_lambda: число с плавающей запятой, которое является коэффициентом регуляризации L2. это лямбда-параметр xgb
scale_pos_weight: число с плавающей запятой, используемое для настройки веса положительных и отрицательных образцов, часто используемое в задачах классификации с дисбалансом классов. По умолчанию 1.
base_score: число с плавающей запятой, дающее начальную оценку прогноза для всех выборок. Он вводит глобальную предвзятость
random_state: Целое число, представляющее начальное значение случайного числа.
пропущено: число с плавающей запятой, значение которого представляет появление пропущенных данных. По умолчанию нан
kwargs: словарь, содержащий аргументы ключевых слов. Используется для установки объекта Booster

xgboost.XGBClassifier: реализует API модели классификации scikit-learn.

class xgboost.XGBClassifier(max_depth=3, learning_rate=0.1, n_estimators=100, 
     silent=True, objective='binary:logistic', booster='gbtree', n_jobs=1,
     nthread=None, gamma=0, min_child_weight=1, max_delta_step=0, subsample=1,
     colsample_bytree=1, colsample_bylevel=1, reg_alpha=0, reg_lambda=1,
     scale_pos_weight=1, base_score=0.5, random_state=0, seed=None, 
     missing=None, **kwargs)

Ссылка на параметр xgboost.XGBRegressor

Методы xgboost.XGBClassifier и xgboost.XGBRegressor:

fit(X, y, sample_weight=None, eval_set=None, eval_metric=None,early_stopping_rounds=None,verbose=True, xgb_model=None) модель поезда
- X: массив, представляющий обучающий набор
- y: последовательность, представляющая токен
- sample_weight: последовательность, указывающая вес каждого образца
- eval_set: список с элементами (X,y), задающими набор проверки и его метки. Они используются для ранней остановки. Если есть несколько наборов проверки, используйте последний
- eval_metric: строка или вызываемый объект для оценки метрики. Если это строка, это имя встроенной метрической функции; если это вызываемый объект, его сигнатура (y_pred,y_true)==>(str,value)
- Early_stopping_rounds: указывает количество ранних остановок. Обратитесь к поезду ()
- verbose: логическое значение. Если True, распечатайте результаты оценки в наборе проверки.
- xgb_model: экземпляр Booster или имя файла, в котором хранится модель xgboost. Это дает модель для обучения. Эта практика позволяет непрерывно тренироваться.
прогнозировать (данные, output_margin = False, ntree_limit = 0) выполнять прогнозирование
- data: объект DMatrix, представляющий тестовый набор
- output_margin: логическое значение. Указывает, следует ли выводить исходное непреобразованное значение поля.
- ntree_limit: целое число. Указывает, сколько поддеревьев использовать для предсказания. Значение по умолчанию равно 0, что означает использование всех поддеревьев.
- Вы можете использовать best_ntree_limit, если во время обучения происходит ранняя остановка.
.predict_proba(data, output_margin=False, ntree_limit=0) Выполнить прогноз, предсказывая вероятность каждой категории. Он используется только для задач классификации и возвращает предсказанные вероятности для каждого класса. Параметры: см. .predict()
.evals_result(): возвращает словарь, содержащий исторические значения каждого набора проверки для каждого параметра проверки. Оно отличается от возвращаемого значения функции cv(). Функция cv() возвращает историю оценок на момент ранней остановки. И здесь возвращаются все исторические значения

Пример:

import xgboost as xgt
import pandas as pd
from sklearn.model_selection import train_test_split
 
_label_map = {
    # 'Iris-setosa':0, #经过裁剪的，去掉了 iris 中的 setosa 类
    'Iris-versicolor': 0,
    'Iris-virginica': 1
}
 
 
class SKLTest:
    def __init__(self):
        df = pd.read_csv('./data/iris.csv')
        _feature_names = ['Sepal Length', 'Sepal Width', 'Petal Length', 'Petal Width']
        x = df[_feature_names]
        y = df['Class'].map(lambda x: _label_map[x])
        
        self.train_X, self.test_X, self.train_Y, self.test_Y = \
            train_test_split(x, y, test_size=0.3, stratify=y, shuffle=True, random_state=1)
 
 
def train_test(self):
    clf = xgt.XGBClassifier(max_depth=3, learning_rate=0.1, n_estimators=100)
    clf.fit(self.train_X, self.train_Y, eval_metric='auc',
            eval_set=[(self.test_X, self.test_Y), ],
            early_stopping_rounds=3)
    # 训练输出:
    # Will train until validation_0-auc hasn't improved in 3 rounds.
    # [0]   validation_0-auc:0.933333
    # ...
    # Stopping. Best iteration:
    # [2]   validation_0-auc:0.997778
    print('evals_result:', clf.evals_result())
    # evals_result: {'validation_0': {'auc': [0.933333, 0.966667, 0.997778, 0.997778, 0.997778]}}
    print('predict:', clf.predict(self.test_X))
# predict: [1 1 0 0 0 1 1 1 0 0 0 1 1 0 1 1 0 1 0 0 0 0 0 1 1 0 0 1 1 0]

API рисования

xgboost.plot_importance (): важность функции графика

xgboost.plot_importance(booster, ax=None, height=0.2, xlim=None, ylim=None,
       title='Feature importance', xlabel='F score', ylabel='Features',
       importance_type='weight', max_num_features=None, grid=True, 
       show_values=True, **kwargs)

параметр:

booster: объект Booster, объект XGBModel или словарь, возвращаемый функцией get_fscore().
ax: объект оси matplotlib. На нем будет нанесена важность функции. Если нет, создайте новые оси
сетка: логическое значение. Если True, включить сетку осей
Important_type: строка, указывающая категорию важности функции. Обратитесь к get_fscore()
max_num_features: целое число, указывающее максимальное количество отображаемых функций. Если нет, показать все функции
высота: число с плавающей запятой, указывающее высоту столбца. он передается в barh()
xlim: кортеж, переданный в xlim()
ylim: кортеж, переданный в ylim()
title: Строка, которая устанавливает название осей. По умолчанию «Важность функции». Если None, без заголовка
xlabel: строка, которая устанавливает заголовок оси X для осей. По умолчанию "оценка F". Если None, ось X не имеет заголовка
ylabel: строка, которая устанавливает заголовок оси Y для осей. По умолчанию «Функции». Если None, ось Y не имеет названия
show_values: логическое значение. Если True, покажите конкретное значение на графике.
kwargs: аргументы ключевого слова для передачи в barh()

xgboost.plot_tree(): нарисовать указанное поддерево

xgboost.plot_tree(booster, fmap='', num_trees=0, rankdir='UT', ax=None, **kwargs)

параметр:

бустер: объект Booster, объект XGBModel
fmap: строка, содержащая имя файла карты объектов.
num_trees: Целое число, указывающее количество поддеревьев, которые нужно отрисовать. По умолчанию 0
rankdir: строка, которая передается в graph_attr графвиза
ax: объект оси matplotlib. На нем будет нанесена важность функции. Если нет, создайте новые оси
kwargs: аргументы ключевого слова для graph_attr передаются в graphviz

xgboost.to_graphviz(): преобразовать указанное поддерево в экземпляр графвиза.

В IPython экземпляры graphviz могут рисоваться автоматически, в противном случае вам нужно вручную вызывать метод .render() объекта graphviz для рисования.

xgboost.to_graphviz(booster, fmap='', num_trees=0, rankdir='UT', yes_color='#0000FF',
     no_color='#FF0000', **kwargs)

параметр:

yes_color: строка, задающая цвет ребер, удовлетворяющих условию узла
no_color: строка, задающая цвет ребер, которые не удовлетворяют условию узла
Обратитесь к plot_tree() для других параметров

Пример:

import xgboost as xgt
import pandas as pd
from sklearn.model_selection import train_test_split
from matplotlib.pylab import plot as plt
 
_label_map = {
    # 'Iris-setosa':0, #经过裁剪的，去掉了 iris 中的 setosa 类
    'Iris-versicolor': 0,
    'Iris-virginica': 1
}
 
 
class PlotTest:
    def __init__(self):
        df = pd.read_csv('./data/iris.csv')
        _feature_names = ['Sepal Length', 'Sepal Width', 'Petal Length', 'Petal Width']
        x = df[_feature_names]
        y = df['Class'].map(lambda x: _label_map[x])
 
        train_X, test_X, train_Y, test_Y = train_test_split(x, y,
                                                            test_size=0.3, stratify=y, shuffle=True, random_state=1)
        self._train_matrix = xgt.DMatrix(data=train_X, label=train_Y,
                                         feature_names=_feature_names,
                                         feature_types=['float', 'float', 'float', 'float'])
        self._validate_matrix = xgt.DMatrix(data=test_X, label=test_Y,
                                            feature_names=_feature_names,
                                            feature_types=['float', 'float', 'float', 'float'])
 
    def plot_test(self):
        params = {
            'booster': 'gbtree',
            'eta': 0.01,
            'max_depth': 5,
            'tree_method': 'exact',
            'objective': 'binary:logistic',
            'eval_metric': ['logloss', 'error', 'auc']
        }
        eval_rst = {}
        booster = xgt.train(params, self._train_matrix,
                            num_boost_round=20, evals=([(self._train_matrix, 'valid1'),
                                                        (self._validate_matrix, 'valid2')]),
                            early_stopping_rounds=5, evals_result=eval_rst, verbose_eval=True)
        xgt.plot_importance(booster)
        plt.show()

Практика оптимизации XGBoost

При оптимизации параметров XGBoost тот же город использует Scikit-learnsklearn.model_selection.GridSearchCV

Интерпретация общих параметров:

оценка: используемый классификатор, если XGBoost используется в соревновании, это сгенерированная модель. Например: модель = xgb.XGBRegressor(**other_params)
param_grid: Значение представляет собой словарь или список, то есть значение параметра, который необходимо оптимизировать. Например: cv_params = {'n_estimators': [550, 575, 600, 650, 675]}
scoring : Критерий оценки точности, значение по умолчанию — None, тогда необходимо использовать функцию оценки или, если scoring='roc_auc', критерии оценки различаются в зависимости от выбранной модели. Строка (имя функции) или вызываемый объект, чья сигнатура функции должна быть в форме: scorer(estimator, X, y); если это None, используется функция оценки ошибки estimator. Параметры оценки выбираются следующим образом:

Конкретный справочный адрес:SCI kit-learn.org/stable/Modu…

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

learning_rate: 0.1
n_estimators: 500
max_depth: 5
min_child_weight: 1
subsample: 0.8
colsample_bytree:0.8
gamma: 0
reg_alpha: 0
reg_lambda: 1

Обычно параметры настраиваются в следующем порядке:

1. Оптимальное количество итераций: n_estimators

if __name__ == '__main__':
    ...
    cv_params = {'n_estimators': [400, 500, 600, 700, 800]}
    other_params = {'learning_rate': 0.1, 'n_estimators': 500, 'max_depth': 5, 'min_child_weight': 1, 'seed': 0,
                    'subsample': 0.8, 'colsample_bytree': 0.8, 'gamma': 0, 'reg_alpha': 0, 'reg_lambda': 1}
    model = xgb.XGBRegressor(**other_params)
    optimized_GBM = GridSearchCV(estimator=model, param_grid=cv_params, scoring='r2', cv=5, verbose=1, n_jobs=4)
    optimized_GBM.fit(X_train, y_train)
    evalute_result = optimized_GBM.grid_scores_
    print('每轮迭代运行结果:{0}'.format(evalute_result))
    print('参数的最佳取值：{0}'.format(optimized_GBM.best_params_))
    print('最佳模型得分:{0}'.format(optimized_GBM.best_score_))

Результат после запуска:

[Parallel(n_jobs=4)]: Done  25 out of  25 | elapsed:  1.5min finished
每轮迭代运行结果:[mean: 0.94051, std: 0.01244, params: {'n_estimators': 400}, mean: 0.94057, std: 0.01244, params: {'n_estimators': 500}, mean: 0.94061, std: 0.01230, params: {'n_estimators': 600}, mean: 0.94060, std: 0.01223, params: {'n_estimators': 700}, mean: 0.94058, std: 0.01231, params: {'n_estimators': 800}]
参数的最佳取值：{'n_estimators': 600}
最佳模型得分:0.9406056804545407

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

cv_params = {'n_estimators': [550, 575, 600, 650, 675]}
other_params = {'learning_rate': 0.1, 'n_estimators': 600, 'max_depth': 5, 'min_child_weight': 1, 'seed': 0,
                    'subsample': 0.8, 'colsample_bytree': 0.8, 'gamma': 0, 'reg_alpha': 0, 'reg_lambda': 1}

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

2. Следующие параметры для отладки — это min_child_weight и max_depth.

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

cv_params = {'max_depth': [3, 4, 5, 6, 7, 8, 9, 10], 'min_child_weight': [1, 2, 3, 4, 5, 6]}
other_params = {'learning_rate': 0.1, 'n_estimators': 550, 'max_depth': 5, 'min_child_weight': 1, 'seed': 0,
                    'subsample': 0.8, 'colsample_bytree': 0.8, 'gamma': 0, 'reg_alpha': 0, 'reg_lambda': 1}

После запуска вы можете узнать лучшее значение параметра: {'min_child_weight': 5, 'max_depth': 4}. (Я опустил часть вывода кода, потому что результат слишком длинный, и то же самое верно ниже)

3. Затем начинаем отлаживать параметры: gamma

cv_params = {'gamma': [0.1, 0.2, 0.3, 0.4, 0.5, 0.6]}
other_params = {'learning_rate': 0.1, 'n_estimators': 550, 'max_depth': 4, 'min_child_weight': 5, 'seed': 0,
                    'subsample': 0.8, 'colsample_bytree': 0.8, 'gamma': 0, 'reg_alpha': 0, 'reg_lambda': 1}

Лучшее значение параметра видно из выходного результата: {'gamma': 0.1}.

4, за которым следует подвыборка и colsample_bytree

cv_params = {'subsample': [0.6, 0.7, 0.8, 0.9], 'colsample_bytree': [0.6, 0.7, 0.8, 0.9]}
other_params = {'learning_rate': 0.1, 'n_estimators': 550, 'max_depth': 4, 'min_child_weight': 5, 'seed': 0,
                    'subsample': 0.8, 'colsample_bytree': 0.8, 'gamma': 0.1, 'reg_alpha': 0, 'reg_lambda': 1}

Показать лучшее значение параметра после запуска: {'subsample': 0,7,'colsample_bytree': 0,7}

5, а затем: reg_alpha и reg_lambda

cv_params = {'reg_alpha': [0.05, 0.1, 1, 2, 3], 'reg_lambda': [0.05, 0.1, 1, 2, 3]}
other_params = {'learning_rate': 0.1, 'n_estimators': 550, 'max_depth': 4, 'min_child_weight': 5, 'seed': 0,
                    'subsample': 0.7, 'colsample_bytree': 0.7, 'gamma': 0.1, 'reg_alpha': 0, 'reg_lambda': 1}

Лучшее значение параметра можно узнать из выходного результата: {'reg_alpha': 1, 'reg_lambda': 1}.

6. ПоследнееLearning_rate, Как правило, скорость обучения должна быть скорректирована для тестирования в это время.

cv_params = {'learning_rate': [0.01, 0.05, 0.07, 0.1, 0.2]}
other_params = {'learning_rate': 0.1, 'n_estimators': 550, 'max_depth': 4, 'min_child_weight': 5, 'seed': 0,
                    'subsample': 0.7, 'colsample_bytree': 0.7, 'gamma': 0.1, 'reg_alpha': 1, 'reg_lambda': 1}

Лучшее значение параметра видно из выходного результата: {'learning_rate': 0,1}.

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

Больше ссылок:

адрес проекта:GitHub.com/Но ФРС/Гонконг освистывает…
Китайский документ:xgboost.apachecn.org
Слайды Чена Тяньци:домов.В это время.Вашингтон.Сумма/~ Подано Чен/PDF…
Бумага XGBoost:АР Вест V.org/ABS/1603.02…
Xgboost использует:у-у-у. huaxiaozhuan.com/%E5%B7%A5%E…
Woohoo.Со слов аналитиков vi.com/blog/2016/0…

Вознаграждение автора WeChat Pay 标点符 wechat qrcode

Alipay