Каждый день мы слышим о прорывах в искусственном интеллекте. Однако, вы задавались вопросом, с какими проблемами он сталкивается?
Проблемы возникают в случае крайне неструктурированных данных, таких как секвенирование ДНК, транзакции по кредитным картам и даже кибербезопасность, которая является основой защиты нашего присутствия в Интернете от мошенников. Эта мысль заставляет вас жаждать узнать больше о науке и обосновании этих систем? Не волнуйтесь! Мы вас прикрыли. В эпоху кибер-технологий машинное обучение (ML) предоставило нам решения этих проблем с внедрением Gradient Boosting Machines (GBM). У нас есть достаточное количество алгоритмов на выбор для повышения градиента для наших обучающих данных, но, тем не менее, мы сталкиваемся с различными проблемами, такими как низкая точность, большие потери, большая разница в результате.
Здесь мы собираемся познакомить вас с современным алгоритмом машинного обучения XGBoost, созданным Тяньци Ченом , который не только преодолеет проблемы, но и исключительно хорошо справится с проблемами регрессии и классификации. Этот блог поможет вам раскрыть знания, методы и навыки с XGBoost, которые вы затем сможете использовать в своих проектах машинного обучения.
XGBoost Взгляд!
eXtreme Gradient Boosting (XGBoost) — это масштабируемая и улучшенная версия алгоритма повышения градиента (терминологическое оповещение), предназначенная для повышения эффективности, скорости вычислений и производительности модели. Это библиотека с открытым исходным кодом и часть сообщества распределенного машинного обучения. XGBoost представляет собой идеальное сочетание программных и аппаратных возможностей, разработанных для повышения точности существующих методов повышения мощности в кратчайшие сроки. Вот краткий обзор объективного сравнения XGBoost с другими алгоритмами повышения градиента, обученного в случайном лесу с 500 деревьями, выполненного Сцилардом Пафкой .
Тест производительности XGBoost
Быстрое воспоминание о повышении
Повышение обычно означает повышение производительности. В ML повышение является последовательной техникой обучения ансамбля (еще одно предупреждение терминологии, не волнуйтесь! Мы также объясним это), чтобы преобразовать слабую гипотезу или слабых учеников в сильных учеников, чтобы повысить точность модели.
Мы можем понять необходимость повышения с помощью простого примера классификации: чтобы классифицировать учетную запись Twitter как бота или человека с помощью базовых правил (ограниченных по степени):
ПРАВИЛА:
- Нет информации об учетной записи и фото профиля → Bot
- Имя пользователя — бред → Бот
- Чириканье на нескольких языках → Бот
- Имеет достаточную активность и профиль → Человек
- Огромное количество твитов в день → Бот
- Другие аккаунты связаны → Человек
Поскольку теперь мы знаем о правилах, давайте применим их на следующем примере:
Сценарий — учетная запись, публикующая твиты на английском и французском языках.
Третье правило классифицирует его как бота, но это будет ложное предсказание, так как человек может знать и писать в Твиттере на нескольких языках. Следовательно, основываясь на одном правиле, наше предсказание может быть ошибочным. Поскольку эти отдельные правила недостаточно сильны, чтобы делать точный прогноз, их называют слабыми учениками. Технически, слабый ученик — это классификатор, который имеет слабую корреляцию с фактическим значением. Поэтому, чтобы сделать наши прогнозы более точными, мы разрабатываем модель, которая объединяет прогнозы слабых учеников, чтобы сделать сильного ученика, и это делается с использованием техники повышения.
Слабые правила генерируются на каждой итерации с помощью базовых алгоритмов обучения, которые в нашем случае могут быть двух типов:
- Дерево как базовый ученик
- Линейная базовая обучаемость
Как правило, деревья решений являются базовыми учениками по умолчанию для повышения.
Хотите узнать больше об учениках? Будьте уверены, в следующем разделе мы продемонстрируем, как использовать базовых учащихся для обучения моделям XGBoost.
Во-первых, давайте познакомимся с вышеупомянутой техникой обучения ансамблю.
Обучение ансамблю
Ансамблевое обучение — это процесс, в котором решения из нескольких моделей машинного обучения объединяются для уменьшения ошибок и улучшения прогнозирования по сравнению с одной моделью ML. Затем метод максимального голосования используется для агрегированных решений (или прогнозов на языке машинного обучения) для получения окончательного прогноза. Озадаченный?
Думайте об этом как об организации эффективных маршрутов к вашей работе / колледжу / или продуктовым магазинам. Поскольку вы можете использовать несколько маршрутов, чтобы добраться до пункта назначения, вы, как правило, изучаете трафик и задержку, которую он может вызвать у вас в разное время дня, позволяя вам разработать идеальный маршрут, обучение ансамблю схоже!
Это изображение показывает четкое различие модели ML по отношению к Ensemble Learner:
Прогноз одиночной модели против ученика ансамбля
Типы обучения ансамблю:
Методы обучения ансамблю могут быть выполнены двумя способами:
- Bagging (параллельный ансамбль)
- Boosting (последовательный ансамбль)
Хотя у обоих есть интересная математика под крышкой, нам не нужно знать это, чтобы иметь возможность подобрать ее в качестве инструмента. В центре нашего внимания будет понимание Boosting из-за его актуальности в XGBoost.
Работа алгоритма повышения:
Алгоритм повышения создает новых слабых учеников (моделей) и последовательно комбинирует их прогнозы, чтобы улучшить общую производительность модели. Для любого неправильного прогноза большие веса присваиваются ошибочно классифицированным выборкам, а более низкие — выборкам, которые правильно классифицированы. Слабые модели учеников, которые работают лучше, имеют больший вес в окончательной модели ансамбля.
Повышение никогда не изменяет предыдущего предиктора и только исправляет следующего предиктора, учась на ошибках. Поскольку ускорение является жадным, рекомендуется установить критерий остановки, такой как производительность модели (ранняя остановка) или несколько этапов (например, глубина дерева у обучающихся на основе дерева), чтобы предотвратить переобучение данных обучения. Первая реализация повышения была названа AdaBoost (Adaptive Boosting).
F(i) is current model, F(i-1) is previous model and f(i) represents weak
model
Внутренняя работа алгоритма повышения
Чувствуете себя готовым? Взгляните на еще два алгоритма (CART и Gradient Boosting), чтобы понять механику XGBoost, прежде чем углубляться в тему.
Деревья классификации и регрессии (CART):
Дерево решений — это контролируемый алгоритм машинного обучения, используемый для прогнозного моделирования зависимой переменной (цели) на основе ввода нескольких независимых переменных. У этого есть древовидная структура с корнем наверху. CART, которая обозначает Деревья классификации и регрессии, используется как общий термин для обозначения следующих типов деревьев решений:
Деревья классификации: где целевая переменная является фиксированной или категориальной, этот алгоритм используется для определения класса / категории, в которую цель, скорее всего, попадет.
Деревья регрессии: где целевая переменная является непрерывной, а дерево / алгоритм используется для прогнозирования ее значения, например, для прогнозирования погоды.
Повышение градиента:
Повышение градиента — это особый случай алгоритма повышения, когда ошибки минимизируются алгоритмом градиентного спуска и создают модель в форме моделей слабого прогнозирования, например деревьев решений.
Основное различие между бустингом и градиентным бустингом заключается в том, как оба алгоритма обновляют модель (слабые учащиеся) из-за неправильных предсказаний. Повышение градиента регулирует вес с помощью градиента (направление в функции потерь) с использованием алгоритма, называемого Gradient Descent , который итеративно оптимизирует потерю модели путем обновления весов. Потеря обычно означает разницу между прогнозируемым значением и фактическим значением. Для алгоритмов регрессии мы используем потерю MSE (средняя квадратическая ошибка), в то время как для задач классификации мы используем логарифмическую потерю.
w represents the weight vector, η is the learning rate
Процесс повышения градиента:
Технологический процесс повышения градиента
Повышение градиента использует Аддитивное моделирование, в котором новое дерево решений добавляется по одному к модели, которая минимизирует потери с использованием градиентного спуска. Существующие деревья в модели остаются нетронутыми и, таким образом, снижают скорость переоснащения. Вывод нового дерева объединяется с выводом существующих деревьев до тех пор, пока потери не будут минимизированы ниже порогового значения или не будет достигнут указанный предел деревьев.
Аддитивное моделирование в математике — это разбиение функции на сложение N подфункций. В статистическом смысле это можно рассматривать как регрессионную модель, в которой отклик y представляет собой арифметическую сумму отдельных эффектов переменных-предикторов x.
XGBOOST в действии!
Что делает XGBoost идеальным алгоритмом для победы в соревнованиях по машинному обучению и Kaggle?
Особенности XGBoost
Разве не интересно увидеть один инструмент для решения всех наших проблем с повышением! Вот особенности с деталями и как они включены в XGBoost, чтобы сделать его надежным.
Улучшения алгоритма:
- Обрезка деревьев — Обрезка — это метод машинного обучения, позволяющий уменьшить размер деревьев регрессии путем замены узлов, которые не способствуют улучшению классификации на листьях. Идея обрезки дерева регрессии состоит в том, чтобы предотвратить переобучение данных обучения. Самый эффективный метод сокращения — Сложность затрат или Слабое сокращение ссылок, который внутренне использует среднеквадратичную ошибку, k-кратную перекрестную проверку и скорость обучения. XGBoost создает узлы (также называемые расщеплениями) с указанным значением max_depth и начинает отсечение назад, пока потеря не окажется ниже порогового значения. Рассмотрим разделение с потерями -3 и последующим узлом с потерями +7, XGBoost не удалит разделение, просто взглянув на одну из отрицательных потерь. Он вычислит общий убыток (-3 + 7 = +4) и, если он окажется положительным, сохранит оба.
- Sparsity Aware Split Finding (Распознавание с разбивкой по разреженным частям) — довольно часто встречающиеся данные имеют разреженность (множество пропущенных или пустых значений) или становятся разреженными после выполнения инженерии данных (кодирование функций). Чтобы быть в курсе разреженности в данных, направление по умолчанию назначает его каждому дереву. XGBoost обрабатывает недостающие данные, назначая их в направлении по умолчанию и находя наилучшее значение вменения, чтобы минимизировать потери при обучении. Оптимизация здесь заключается в посещении только пропущенных значений, которые заставляют алгоритм работать в 50 раз быстрее, чем простой метод.
Улучшения системы:
- Распараллеливание — древовидное обучение требует данных в отсортированном виде. Чтобы сократить расходы на сортировку, данные делятся на сжатые блоки (каждый столбец с соответствующим значением объекта). XGBoost сортирует каждый блок параллельно, используя все доступные ядра / потоки процессора. Эта оптимизация полезна, так как большое количество узлов часто создается в дереве. Короче говоря, XGBoost распараллеливает последовательный процесс генерации деревьев.
- Cache Aware — Оптимизируя кэш-память, мы храним статистику градиента (направление и значение) для каждого разделенного узла во внутреннем буфере каждого потока и выполняем накопление в виде мини-пакета. Это помогает сократить время, затрачиваемое на немедленные операции чтения / записи, а также предотвратить потерю кэша . Осведомленность о кеше достигается путем выбора оптимального размера блока (обычно 2 ^ ¹⁶).
Гибкость в XGBoost:
- Настроенная целевая функция — целевая функция предназначена для максимизации или минимизации чего-либо. В ML мы стараемся минимизировать целевую функцию, которая является комбинацией функции потерь и члена регуляризации.
L(Φ) is objective function
Оптимизация функции потерь поощряет прогнозные модели, тогда как оптимизация регуляризации приводит к меньшей дисперсии и делает прогнозирование стабильным. Различные целевые функции, доступные в XGBoost:
-
рег: линейный для регрессии
-
reg: логистика и бинарный: логистика для бинарной классификации
-
multi: softmax и multi: softprob для мультиклассовой классификации
2. Индивидуальная метрика оценки — это метрика, используемая для контроля точности модели на данных валидации.
- rmse — среднеквадратическая ошибка (регрессия)
- mae — средняя абсолютная ошибка (регрессия)
- ошибка — ошибка двоичной классификации (классификация)
- logloss — отрицательное логарифмическое правдоподобие (классификация)
- auc — площадь под кривой (классификация)
Перекрестная проверка:
- Встроенная перекрестная проверка — перекрестная проверка — это статистический метод оценки моделей машинного обучения по невидимым данным. Это удобно, когда набор данных ограничен, и предотвращает переоснащение, не беря независимую выборку (удержание) из обучающих данных для проверки. Сокращая объем обучающих данных, мы идем на компромисс с функциями и шаблонами, скрытыми в данных, которые могут дополнительно вызвать ошибки в нашей модели. Это похоже на функциональность cross_val_score, предоставляемую библиотекой sklearn.
XGBoost использует встроенную функцию перекрестной проверки cv ():
xgb.cv()
Хотите промочить ноги? (Это время кодирования)
питон
xxxxxxxxxx
1
## XGBOOST Cross Validation
2
import xgboost as xgb
4
import pandas as pd
5
from sklearn.datasets import load_boston
6
X, y = load_boston(return_X_y=True)
8
boston_dmatrix = xgb.DMatrix(data=X, label=y)
10
#
12
reg_params = [1, 10, 100]
13
# params
15
params = {"objective": "reg:squarederror", "max_depth": 3}
16
# Create an empty list for storing rmses as a function of ridge regression complexity
18
ridge_regression = []
19
# Iterate over reg_params
21
for reg in reg_params:
22
# Update l2 strength
24
params["lambda"] = reg
25
# Pass this updated param dictionary into cv
27
cv_results_rmse = xgb.cv(dtrain=boston_dmatrix, params=params, nfold=5, num_boost_round=5, metrics="rmse", as_pandas=True, seed=123)
28
# Append best rmse (final round)
30
ridge_regression.append(cv_results_rmse["test-rmse-mean"].tail(1).values[0])
31
# Look at best rmse per regularization param
33
print("Best RMSE as a function of ridge regression (L2 regularization):")
34
print(pd.DataFrame(list(zip(reg_params, ridge_regression)), columns=["l2", "rmse"]))
2. k-кратная перекрестная проверка - при k-кратной перекрестной проверке данные перемешиваются и делятся на k подвыборок одинакового размера. Один из k подвыборок используется в качестве набора для проверки / проверки, а остальные (k -1) подвыборки объединяются для использования в качестве обучающих данных. Затем мы подбираем модель, используя данные обучения, и оцениваем, используя набор тестов Этот процесс повторяется k раз, так что каждая точка данных остается в установленной проверке ровно один раз. K результатов из каждой модели должны быть усреднены, чтобы получить окончательную оценку. Преимущество этого метода заключается в том, что мы значительно уменьшаем смещение и дисперсию, а также повышаем надежность модели.
Кросс-валидация в k-кратном порядке с использованием sklearn в XGBoost:
from sklearn.model_selection import KFold, cross_val_score
kfold = KFold(n_splits=1)
xgboost_score = cross_val_score(xg_cl, X, y, cv=kfold)
Тюнинг Как Профи! (Модель тюнинг)
Настройка модели в XGBoost может быть реализована с помощью стратегий перекрестной проверки, таких как GridSearchCV и RandomizedSearchCV .
1. Поиск по сетке - мы передаем словарь параметров функции, затем она сравнивает оценку перекрестной проверки для каждой комбинации параметров (от многих ко многим) в словаре и возвращает набор, имеющий лучшие параметры.
2. Случайный поиск - случайным образом выводит значение во время каждой итерации из диапазона указанных значений для каждого перебираемого гиперпараметра и оценивает модель с этими гиперпараметрами. После завершения всех итераций он выбирает конфигурацию гиперпараметра с наилучшей оценкой.
питон
xxxxxxxxxx
1
## XGBOOST Model Tuning
2
import xgboost as xgb
4
import numpy as np
5
from sklearn.model_selection import GridSearchCV
6
from sklearn.model_selection import RandomizedSearchCV
7
from sklearn.datasets import load_boston
8
X, y = load_boston(return_X_y=True)
10
dmatrix = xgb.DMatrix(data=X, label=y)
12
# Grid Search Parameters
14
grid_search_params = {
15
'colsample_bytree': [0.3, 0.7],
16
'learning_rate': [0.01, 0.1, 0.2, 0.5],
17
'n_estimators': [100],
18
'subsample': [0.2, 0.5, 0.8],
19
'max_depth': [2, 3, 5]
20
}
21
xg_grid_reg = xgb.XGBRegressor(objective= "reg:squarederror")
23
grid = GridSearchCV(estimator=xg_grid_reg, param_grid=grid_search_params, scoring='neg_mean_squared_error',
25
cv=4, verbose=1, iid=True)
26
grid.fit(X, y)
28
print("GridSearchCV")
29
print("Best parameters found: ", grid.best_params_)
30
print("Lowest RMSE found: ", np.sqrt(np.abs(grid.best_score_)))
31
# Random Search Parameters
34
params_random_search = {
35
'learning_rate': np.arange(0.01, 1.01, 0.01),
36
'n_estimators': [200],
37
'max_depth': range(2, 12),
38
'subsample': np.arange(0.02, 1.02, 0.02)
39
}
40
xg_random_reg = xgb.XGBRegressor(objective= "reg:squarederror")
43
randomized_mse = RandomizedSearchCV(param_distributions=params_random_search, estimator=xg_random_reg,
45
scoring="neg_mean_squared_error", n_iter=5, cv=4, verbose=1, iid=True)
46
randomized_mse.fit(X, y)
47
print("Randomize Search Cross Validation")
49
print("Best parameters found: ", randomized_mse.best_params_)
50
print("Lowest RMSE found: ", np.sqrt(np.abs(randomized_mse.best_score_)))
вывод с использованием сетки поиска
вывод с использованием случайного поиска
Общее количество конфигураций в сетчатом поиске → 2 * 4 * 1 * 3 * 3 = 72
Общее количество конфигураций в случайном поиске → 100 * 1 * 10 * 50 = 50000
Расширяемость:
- Классификация с использованием XGBoost
питон
xxxxxxxxxx
1
## XGBOOST Classification
2
import numpy as np
4
from numpy import loadtxt
5
import xgboost as xgb
6
from matplotlib import pyplot
7
from sklearn.model_selection import train_test_split
8
# load data
10
df = loadtxt('./dataset.csv', delimiter=",")
11
# Split data into X and y
13
X = df[:, 0:8]
14
y = df[:, 8]
15
# Spilt into train and test
17
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=123)
18
# XGB Classifier
20
xg_cl = xgb.XGBClassifier(objective='binary:logistic', n_estimators=100, seed=123)
21
eval_set = [(X_train, y_train), (X_test, y_test)]
22
# Fit the classifier to the training set
24
xg_cl.fit(X_train, y_train, eval_metric=["error"], eval_set=eval_set, verbose=True)
25
results = xg_cl.evals_result()
26
# Predict the labels of the test set: preds
28
predictions = xg_cl.predict(X_test)
29
# Compute the accuracy: accuracy
31
accuracy = float(np.sum(predictions == y_test))/y_test.shape[0]
32
print("accuracy: %f" % (accuracy*100))
33
# plot classification error
35
epochs = len(results['validation_0']['error'])
36
x_axis = range(0, epochs)
37
fig, ax = pyplot.subplots()
38
ax.plot(x_axis, results['validation_0']['error'], label='Train')
39
ax.plot(x_axis, results['validation_1']['error'], label='Test')
точность классификации xgboost
Ошибка классификации
2. Регрессия с использованием XGBoost:
2.1. Базовое обучение по дереву решений
питон
xxxxxxxxxx
1
## XGBOOST Regression - Decision Tree Based
2
import xgboost as xgb
4
import pandas as pd
5
from sklearn.model_selection import train_test_split
6
from sklearn.metrics import explained_variance_score
7
# KC House Data
9
df = pd.read_csv('./kc_house_data.csv')
10
df_train = df[['bedrooms', 'bathrooms', 'sqft_living', 'floors', 'waterfront', 'view', 'grade', 'lat', 'yr_built', 'sqft_living15']]
11
X = df_train.values
13
y = df.price.values
14
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=123)
16
# Fitting XGB regressor model and default base learner is Decision Tree
18
xgb_reg = xgb.XGBRegressor(objective="reg:linear", n_estimators=75, subsample=0.75, max_depth=7)
19
xgb_reg.fit(X_train, y_train)
20
# Making Predictions
22
predictions = xgb_reg.predict(X_test)
23
# Variance_score
25
print((explained_variance_score(predictions, y_test)))
26
# To convert data table into a matrix
28
kc_dmatrix = xgb.DMatrix(data=X, label=y, feature_names=df_train)
29
# Create the parameter dictionary: params
31
params = {"objective": "reg:linear", "max_depth": 2}
32
# Train the model: xg_reg
34
xg_reg = xgb.train(params=params, dtrain=kc_dmatrix, num_boost_round=10)
35
# Plot the first tree as num_trees = 0 and features importance
37
xgb.plot_tree(xg_reg, num_trees=0)
38
xgb.plot_importance(xg_reg)
отклонение от регрессии xgboost с деревом решений в качестве базового ученика
Древовидные графики с использованием дерева решений (XGBRegressor)
2.2. Линейное базовое обучение
питон
xxxxxxxxxx
1
## XGBOOST Regression Linear Base Learning
2
import numpy as np
4
import xgboost as xgb
5
from sklearn.datasets import load_boston
6
from sklearn.metrics import mean_squared_error
7
from sklearn.model_selection import train_test_split
8
# Linear Base Learner
10
X, y = load_boston(return_X_y=True)
11
# Train and test split
13
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=123)
14
# Convert the training and testing sets into DMatrixes
16
boston_train = xgb.DMatrix(data=X_train, label=y_train)
17
boston_test = xgb.DMatrix(data=X_test, label=y_test)
18
# Parameters with booster as gblinear for Linear base learner
20
params = {"booster": "gblinear", "objective": "reg:linear"}
21
# Train the model: xg_reg
23
xg_reg = xgb.train(params=params, dtrain=boston_train, num_boost_round=5)
24
# Making predictions
26
predictions = xg_reg.predict(boston_test)
27
# Computing RMSE
29
print("RMSE: %f" % (np.sqrt(mean_squared_error(y_test, predictions))))
Использование регрессии xgboost с линейным базовым учеником
Модуль Важность Участка:
Библиотека XGBoost предоставляет встроенную функцию для отображения функций, упорядоченных по их важности. Функция - plot_importance (модель) и принимает обученную модель в качестве параметра. Функция предоставляет информативную гистограмму, представляющую значимость каждого объекта, и присваивает им имена в соответствии с их индексом в наборе данных. Важность рассчитывается на основе переменной priority_type, которая принимает
веса параметров (по умолчанию) - сообщает время появления элемента в
коэффициенте усиления дерева - представляет собой среднюю потерю обучения, полученную при использовании функции
'cover' - которая сообщает охват разбиений, то есть количество раз, когда объект используется, взвешенный по общему количеству тренировочных баллов, которые попадают в эту ветку.
xgb.plot_importance(model)
Анализ важности характеристик набора данных жилья
Спасибо за чтение этой статьи!
Соавторы - Рохан Хароде, Акаш Сингх Кунвар
Ссылки
[1] https://arxiv.org/abs/1603.02754
[2] https://machinelearningmastery.com/gentle-introduction-xgboost-applied-machine-learning/
[3] https://explained.ai/gradient- boosting / index.html
[4] https://github.com/dmlc/xgboost
[5] https://towardsdatascience.com/ensemble-methods-bagging-boosting-and-stacking-c9214a10a205