МЕТОД БУСТИНГА

Ансамблевые методы машинного обучения

Ансамблевые методы — это мощный инструмент для построения моделей машинного обучения. Команды, которые используют их в соревнованиях на kaggle, занимают победные места. Ансамбли позволяют увеличить точность модели до 90+, при этом они довольно просты в понимании.

Поэтому я решил осветить эту тему в данной статье и показать реализацию ансамблей с помощью scikit-learn.

Что такое ансамбль?

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

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

Виды ансамблевых методов

Наиболее популярными ансамблевыми методами являются: стекинг, бэггинг, бустинг.

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

• Бэггинг
  . В этом случае однородные модели обучают на разных наборах данных и объединяют. Получают прогноз путём усреднения. Если использовать в качестве слабого ученика деревья решений, то получится случайный лес RandomForestClassifier
  / RandomForestRegressor
  .

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

Стекинг

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

При обучении мета-модели используется приём удерживаемого набора. Сначала набор разделяется на 2 части. Слабые ученики обучаются на первой половине обучающего набора, затем на второй. Затем создаётся новый обучающий набор на основе прогнозов, сделанных на прогнозах первой и второй части набора. Таким образом, на каждый образец из входного набора приходится столько прогнозов, сколько слабых учеников в ансамбле (в примере на картинке три). Мета-модель учится прогнозировать значения на основе нового набора.

Код на Python

   from sklearn.ensemble import StackingClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split

data, target = load_breast_cancer(return_X_y=True)

estimators = [('lr', LogisticRegression()), ('dt', DecisionTreeClassifier())]
modelClf = StackingClassifier(estimators=estimators, final_estimator=SVC())

X_train, X_valid, y_train, y_valid = train_test_split(data, target, test_size=0.3, random_state=12)

modelClf.fit(X_train, y_train)
print(modelClf.score(X_valid, y_valid))
  
  

Ссылка на документацию: Классификатор
/ Регрессор
.

Бэггинг

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

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

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

Код на Python

   from sklearn.datasets import load_breast_cancer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.ensemble import BaggingClassifier

data, target = load_breast_cancer(return_X_y=True)

modelClf = BaggingClassifier(base_estimator=LogisticRegression(), n_estimators=50, random_state=12)

X_train, X_valid, y_train, y_valid = train_test_split(data, target, test_size=0.3, random_state=12)

modelClf.fit(X_train, y_train)
print(modelClf.score(X_valid, y_valid))
  
  

Ссылка на документацию: Классификатор
/ Регрессор
.

Бустинг

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

Базовые модели для бустинга — это модели с низким разбросом и высоким смещением. Например неглубокие деревья решений. Одна из причин такого выбора моделей — они требуют меньше вычислительных затрат. Ещё бустинг (в отличии от бэггинга) нельзя распараллелить.

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

Адаптивный бустинг (AdaBoost)

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

Результат работы AdaBoost — это средневзвешенная сумма каждой модели. Спрогнозированным значением ансамбля будет тот, который получает большинство взвешенный голосов

Adaboost обновляет веса объектов на каждой итерации. Веса хорошо классифицированных объектов уменьшаются относительно весов неправильно классифицированных объектов. Модели, которые работают лучше, имеют больший вес в окончательной модели ансамбля.

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

Код на Python:

   from sklearn.datasets import load_breast_cancer
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn.ensemble import AdaBoostClassifier

data, target = load_breast_cancer(return_X_y=True)

modelClf = AdaBoostClassifier(base_estimator=DecisionTreeClassifier(max_depth=2), n_estimators=100, random_state=12)

X_train, X_valid, y_train, y_valid = train_test_split(data, target, test_size=0.3, random_state=12)

modelClf.fit(X_train, y_train)
print(modelClf.score(X_valid, y_valid))
  
  

Ссылка на документацию: Классификатор
/ Регрессор
.

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

Таким образом градиентный бустинг — обобщение адаптивного бустинга для дифференцируемых функций.

   from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.ensemble import GradientBoostingClassifier

data, target = load_breast_cancer(return_X_y=True)

modelClf = GradientBoostingClassifier(max_depth=2, n_estimators=150,
                                      random_state=12, learning_rate=1)

X_train, X_valid, y_train, y_valid = train_test_split(data, target, 
                                                      test_size=0.3, random_state=12)

modelClf.fit(X_train, y_train)
print(modelClf.score(X_valid, y_valid))
  
  

Ссылка на документацию: Классификатор
/ Регрессор
.

Вывод

Ансамблевые модели являются мощным инструментом для анализа данных. Идея об объединении простых моделей, позволила делать лучшие прогнозы. Но всё же для построения прогнозов сначала необходимо применять более простые модели, потому что используя их можно добиться нужной точности. Если же результаты вас не устраивают, то можно применять ансамбли.

Помимо библиотеки scikit-learn в python есть библиотека XGBoost, которая предоставляет более обширный набор ансамблевых моделей с более точной реализацией.

Классификация признаков в компьютерном зрении

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

Задача классификации объектов

Статус кво для классификации объектов

Бустинг для двоичной классификации

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

1. Формируем большой набор признаков
2. Инициализируем веса для тренировочного набора изображений
3. Делаем T прогонов
   1. Нормализуем веса
   2. Для доступных признаков из набора тренируем классификатор, используя один из признаков и вычисляем ошибку тренировки
   3. Выбираем классификатор с наименьшей ошибкой
   4. Обновляем веса тренировочных изображений: увеличиваем, если классифицировано неверно, и уменьшаем, если верно
4. Формируем окончательный сильный классификатор как линейная комбинация T классификаторов (коэффициент больше, если ошибка тренировки меньше)

Бустинг мультиклассовой классификации

• Scikit-learn
  , библиотека машинного обучения с открытым кодом для языка Python
• , a свободно распространяемый программный комплекс для анализа данных, модуль Orange.ensemble
  Архивная копия
  от 4 марта 2016 на Wayback Machine
• Weka
   — это набор средств для машинного обучения, содержащий ряд реализаций алгоритмов бустинга, таких как AdaBoost и LogitBoost
• Пакет GBM (Generalized Boosted Regression Models) на языке R
  реализует расширение алгоритма Фройнда и Шапире AdaBoost и градиентного бустинга Фридмана.
• Jboost; AdaBoost, LogitBoost, RobustBoost, Boostexter и чередующиеся решающие деревья
  
• Пакет adabag языке R: Применяет мультиклассовые алгоритмы AdaBoost. M1, AdaBoost-SAMME и Bagging
• Пакет xgboost на языке R: Реализация градиентного бустинга для линейных основанных на деревьях моделей.
• Пакет CatBoost

1. . Некоторые основанные на бустинге алгоритмы классификации на самом деле уменьшают веса повторно неверно классифицированных экземпляров. Например, бустинг по доминированию ( англ.
     boost by majority
   ) и BrownBoost
   

• Robert E. Schapire (2003); The Boosting Approach to Machine Learning: An Overview
  
  Архивная копия
  от 20 сентября 2020 на Wayback Machine
  , MSRI (Mathematical Sciences Research Institute) Workshop on Nonlinear Estimation and Classification
• Zhou Zhi-Hua
  (2014) Boosting 25 years
  
  Архивная копия
  от 20 августа 2016 на Wayback Machine
  , CCL 2014 Keynote.
• Zhihua Zhou.
  On the margin explanation of boosting algorithm.
   // Proceedings of the 21st Annual Conference on Learning Theory (COLT’08). — 2008. — .
• Zhihua Zhou.
  On the doubt about margin explanation of boosting.
   // Artificial Intelligence. — 2013. — . — . — doi
  : 10.1016/j.artint.2013.07.002
  . — arXiv
  : 1009.3613
  .
• http://www.machinelearning.ru/wiki/index.php?title=%D0%91%D1%83%D1%81%D1%82%D0%B8%D0%BD%D0%B3
  Архивная копия
  от 24 февраля 2020 на Wayback Machine

Повышение градиентного дерева

Методы сбора ансамблей алгоритмов машинного обучения

Что такое модели моделей?

По названию можно догадаться, что ансамбль — это просто несколько алгоритмов машинного обучения, собранных в единое целое. Такой подход часто используется для того, чтобы усилить «положительные качества» отдельно взятых алгоритмов, которые сами по себе могут слабо работать, а вот в группе — ансамбле дают хороший результат. При использовании обоих методов алгоритмы учатся одновременно и могут исправить ошибки друг друга. Типичными примерами методов, направленных на объединение «слабых» компонентов в группу сильных являются (рис. 1):

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

• Бэггинг.
  Рассматриваются однородные модели, которые обучаются независимо и параллельно, а затем их результаты просто усредняются. Ярким представителем данного метода является случайный лес.

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

Три этих выхода и более подробные обзоры далее.

Стекинг

Из трех вариантов стекинг очень популярен. Это можно отслеживать и по результатам готовых реализаций данного метода в программных библиотеках. В том же sklearn.ensemble в python куда чаше использовать AdaBoost, Bagger, GradientBoosting, чем тот же самый Stacking (хотя его реализация там тоже есть).

Стекинг отдельных двух дополнительных черт: он может преподавать в себе алгоритмы разной природы в качестве базовых. Например, взять метод опорных векторов (SVM), к-ближайших соседей (KNN) в качестве базовых и на основе их результатов обучить логистическую регрессию для классификации. Также стоит отметить непредсказуемость работы метамодели. Если в случае бэггинга и бустинга существует достаточно четкий и конкретный ансамблевый алгоритм (увидим далее), то здесь метамодель может с течением времени по-разному обучаться на входных данных.

Алгоритм обучения выглядит следующим образом (рис. 2):

• Делим выборку на k фолдов
  (тот же смысл, что и в кросс-валидации).

• Для объекта из выборки, который находится в k-ом фолде
  , делается предсказание слабыми алгоритмами, которые были обучены на k-1 фолдах.
  Этот процесс итеративен и происходит для каждого фолда.

• Создается набор прогнозов слабых алгоритмов для каждого объекта выборки.

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

  

Ссылки на библиотеки для использования метода приведены ниже:

Бэггинг

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

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

Для того, чтобы понять, каким образом исходный датасет делится для формирования входных выборок для слабых алгоритмов, используется понятие бутстрэпа
. При использовании бутстрэпа из исходной выборки берется один случайный элемент, записывается в обучающую выборку, затем возвращается обратно. Так делается n раз, где n — желаемый размер обучающей выборки. Существует правило, что в обучающей выборке в итоге будет ~ 0.632*n разных объектов. Таким образом, должны сформироваться m обучающих выборок для m слабых алгоритмов.

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

Что касается агрегации выходов базовых алгоритмов, то в случае задачи классификации зачастую просто выбирается наиболее часто встречающийся класс, а в случае задачи регрессии выходы алгоритмов усредняются (рис. 3). В формуле под ai
подразумеваются выходы базовых алгоритмов.

Общий процесс приведен на рисунке ниже (рис. 4):

Бэггинг направлен на уменьшение разброса (дисперсии) в данных, и зачастую данный прием предстает в виде алгоритма случайного леса, где слабые модели — это довольно глубокие случайные деревья. Однако, при построении случайного леса используется еще один прием, такой как метод случайных подпространств.
Мало того, что благодаря бутсрэпу выбираются некоторые объекты нашего датасета, так еще и выбирается случайное подмножество признаков. В итоге, наша условная матрица признаков уменьшается как по строкам, так и столбцам (рис. 5). Это помогает действительно снизить корреляцию между слабыми учениками.

Ссылки на библиотеки для использования метода приведены ниже:

Бустинг

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

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

Типичными представителями бустинга являются две модели: градиентный бустинг и AdaBoost. Обе по-разному решают одну и ту же оптимизационную задачу по поиску итоговой модели, представляющей собой взвешенную сумму слабых алгоритмов (рис. 6).

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

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

• Этот вектор сдвига является антиградиентом от функции ошибок работы предыдущего ансамбля моделей

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

• А поскольку нам надо найти очередной алгоритм в композиции, то находим тот, при использовании которого минимизируется отклонение ответов от истинных

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

Ссылки на библиотеки для использования метода приведены ниже:

Классификация градиентным бустингом
, классификация AdaBoost-ом

Регрессия градиентным бустингом
, регрессия AdaBoost-ом

Заключение

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

   ### Загружаем библиотеки и данные
import pandas as pd
import numpy as np
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler,LabelEncoder
from sklearn.datasets import load_breast_cancer
from sklearn.metrics import mean_squared_error,r2_score 

import warnings
warnings.filterwarnings('ignore')
breast_cancer = load_breast_cancer()


### Обозначаем целевую переменную для нашей будущей модели
X = pd.DataFrame(breast_cancer['data'], columns=breast_cancer['feature_names'])
y = pd.Categorical.from_codes(breast_cancer['target'], breast_cancer['target_names'])

lbl = LabelEncoder() 
lbl.fit(y)

y_enc = lbl.transform(y)


### Разбираемся с признаками
scl = StandardScaler()
scl.fit(X)
X_scaled = scl.transform(X)

X_train, X_test, y_train, y_test = train_test_split(X, y_enc, test_size=0.20, random_state=42)


### Прописываем параметры для нашей модели 
params = {'n_estimators':200,
          'max_depth':12,
          'criterion':'mse',
          'learning_rate':0.03,
          'min_samples_leaf':16,
          'min_samples_split':16
          }


### Тренируем
gbr = GradientBoostingRegressor(**params)
gbr.fit(X_train,y_train)


### Вычисляем точность
train_accuracy_score=gbr.score(X_train,y_train)
print(train_accuracy_score)

test_accuracy_score=gbr.score(X_test,y_test)
print(test_accuracy_score)

### Предсказание
y_pred = gbr.predict(X_test)

### И среднеквадратичную ошибку
mse = mean_squared_error(y_test,y_pred)
print("MSE: %.2f" % mse)
print(r2_score(y_test,y_pred))  

  

   0.9854271477118486
0.8728770740774442
MSE: 0.03
0.8728770740774442  

  

   pip install xgboost  

  

   # xgboost для классификации
from numpy import asarray
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from xgboost import XGBClassifier
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
# определяем датасет
X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, n_redundant=5, random_state=1)
# и нашу модель вместе с кросс-валидацией
model = XGBClassifier()
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
print('Точность: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
# тренируем модель на всём наборе данных
model = XGBClassifier()
model.fit(X, y)
# предсказываем
row = [2.56999479, -0.13019997, 3.16075093, -4.35936352, -1.61271951, -1.39352057, -2.48924933, -1.93094078, 3.26130366, 2.05692145]
row = asarray(row).reshape((1, len(row)))
yhat = model.predict(row)
print('Предсказание (Предикт): %d' % yhat[0])  

  

   # xgboost для регрессии
from numpy import asarray
from numpy import mean
from numpy import std
from sklearn.datasets import make_regression
from xgboost import XGBRegressor
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedKFold
# определяем датасет
X, y = make_regression(n_samples=1000, n_features=10, n_informative=5, random_state=1)
# и нашу модель (в данном примере мы меняем метрику на MAE)
model = XGBRegressor(objective='reg:squarederror')
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(model, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1, error_score='raise')
print('MAE (Средняя Абсолютная Ошибка): %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
# тренируем модель на всём наборе данных
model = XGBRegressor(objective='reg:squarederror')
model.fit(X, y)
# предсказываем
row = [2.02220122, 0.31563495, 0.82797464, -0.30620401, 0.16003707, -1.44411381, 0.87616892, -0.50446586, 0.23009474, 0.76201118]
row = asarray(row).reshape((1, len(row)))
yhat = model.predict(row)
print('Предсказание (Предикт): %.3f' % yhat[0])
  

  

   pip install lightgbm  

  

   # lightgbm для классификации
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from lightgbm import LGBMClassifier
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
# определяем датасет
X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, n_redundant=5, random_state=1)
# и нашу модель
model = LGBMClassifier()
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
print('Точность: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
# тренируем модель на всём наборе данных
model = LGBMClassifier()
model.fit(X, y)
# предсказываем
row = [[2.56999479, -0.13019997, 3.16075093, -4.35936352, -1.61271951, -1.39352057, -2.48924933, -1.93094078, 3.26130366, 2.05692145]]
yhat = model.predict(row)
print('Предсказание (Предикт): %d' % yhat[0])  

  

   # lightgbm для регрессии
from numpy import mean
from numpy import std
from sklearn.datasets import make_regression
from lightgbm import LGBMRegressor
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedKFold
# определяем датасет
X, y = make_regression(n_samples=1000, n_features=10, n_informative=5, random_state=1)
# и нашу модель (в данном примере мы меняем метрику на MAE)
model = LGBMRegressor()
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(model, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1, error_score='raise')
print('MAE (Средняя Абсолютная Ошибка): %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
# тренируем модель на всём наборе данных
model = LGBMRegressor()
model.fit(X, y)
# предсказываем
row = [[2.02220122, 0.31563495, 0.82797464, -0.30620401, 0.16003707, -1.44411381, 0.87616892, -0.50446586, 0.23009474, 0.76201118]]
yhat = model.predict(row)
print('Предсказание (Предикт): %.3f' % yhat[0])  

  

Текущая версия страницы пока не проверялась
опытными участниками и может значительно отличаться от версии
, проверенной 1 июня 2022 года; проверки требуют 3 правки
.

• Умная штрафовка деревьев
• Пропорциональное уменьшение узлов листьев
• Метод Ньютона
  в оптимизации
• Дополнительный параметр рандомизации
• Реализация на одиночных, распределенных
  системах и out-of-core
  вычислениях
• Автоматический отбор признаков

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

Общий вид нерегуляризованного алгоритма XGBoost:

• Премия John Chambers
  (2016)
  ^[18]
  
• Премия High Energy Physics meets Machine Learning award (HEP meets ML) (2016)
  ^[19]