Повышение градиента – это метод машинного обучения для объединения, итеративным образом, ряд слабых прогнозных моделей в единую сильную прогностическую модель. XGBOOST – это уникальная форма повышения градиента с несколькими различными преимуществами. Чтобы понять преимущества XGBOOST по сравнению с традиционным повышением градиента, вы должны сначала узнать, как работает традиционное повышение градиента. Общая структура и гиперпараметры традиционного повышения градиента включены в XGBOOST.
В этой статье вы обнаружите силу повышения градиента, которое лежит в основе XGBOOST. Вы будете создавать модели повышения градиента с нуля, прежде чем сравнивать модели повышения градиента и ошибки с предыдущими результатами. В частности, вы сосредоточитесь на Скорость обучения Гиперпараметр для создания мощных моделей повышения градиента, которые включают XGBOOST. Наконец, вы просмотрите тематическое исследование по экзопланетам, которое подчеркивает необходимость более быстрых алгоритмов, что является критической потребностью в мире больших данных, которые удовлетворяются XGBOOST.
Мы будем освещать следующие темы:
- От пакета до повышения
- Как работает повышение градиента
- Модификация повышения градиента гиперпараметров
- Подход к большим данным – повышение градиента по сравнению с XGBOOST с Python
Код для этой статьи доступен в https://github.com/packtpublishing/hands-on-gradient-boosting-with-xgboost-and-scikit-learn/tree/master/chapter04 .
Предполагается некоторое знакомство с программированием Python.
Алгоритмы ансамблевого машинного обучения, такие как Случайные леса Чтобы сделать лучшие прогнозы, объединив многие модели машинного обучения в одну. Случайные леса классифицируются как алгоритмы мешков, потому что они берут агрегаты загрузочных образцов (деревья решений).
Повышение, напротив, учится на ошибках отдельных деревьев. Общая идея состоит в том, чтобы настроить новые деревья на основе ошибок предыдущих деревьев.
При повышении исправление ошибок для каждого нового дерева является отчетливым подходом от мешков. В модели мешков новые деревья не обращают внимания на предыдущие деревья. Кроме того, новые деревья строятся с нуля с использованием начальной загрузки, а окончательная модель объединяет все отдельные деревья. Однако при повышении каждого нового дерева построено из предыдущего дерева. Деревья не работают изолированно; Вместо этого они построены друг на друга.
Представляем Adaboost
Adaboost является одной из самых ранних и популярных моделей повышения. В Adaboost каждое новое дерево регулирует свои веса на основе ошибок предыдущих деревьев. Больше внимания уделяется предсказаниям, которые пошли не так, приспосабливая веса, которые влияют на эти образцы с более высоким процентом. Учившись на своих ошибках, Adaboost может превратить слабых учеников в сильных учеников. Слабый ученик – это алгоритм машинного обучения, который едва работает лучше, чем случайно. В отличие от этого, более сильный ученик выучил значительную сумму из данных и работает довольно хорошо.
Общая идея повышения алгоритмов состоит в том, чтобы превратить слабых учеников в сильных учеников. Слабый ученик вряд ли лучше, чем случайные догадки. Но есть цель за слабым стартом. Опираясь на эту общую идею, повышение работ, сосредоточив внимание на коррекции итеративных ошибок, а не путем создания сильной базовой модели. Если базовая модель слишком сильна, процесс обучения обязательно ограничен, тем самым подрывая общую стратегию, лежащую в основе моделей.
Слабые ученики превращаются в сильных учеников через сотни итераций. В этом смысле небольшой край проходит долгий путь. Фактически, за последние пару десятилетий повышение было одной из лучших стратегий общего машинного обучения с точки зрения получения оптимальных результатов.
Как и во многих моделях Scikit-Learn, легко реализовать Adaboost на практике. Алгоритмы Adaboostregressor и Adaboostclassifier могут быть загружены из библиотеки Sklearn.ensemble и соответствовать любому учебному набору. Наиболее важным гиперпараметром Adaboost является N_ESTIMATORS, количество деревьев (итераций), необходимых для создания сильного ученика.
Примечание
Для получения дополнительной информации об Adaboost, ознакомьтесь с официальной документацией: Классификаторы и Регрессоры Анкет
Теперь мы перейдем к повышению градиента, сильной альтернативой Adaboost с небольшим преимуществом производительности.
Отличительное повышение градиента
Укрепление градиента использует другой подход, чем Adaboost. В то время как повышение градиента также корректируется на основе неправильных прогнозов, эта идея делает еще один шаг вперед: повышение градиента полностью подходит для каждого нового дерева на основе ошибок предыдущих предсказаний дерева. То есть для каждого нового дерева, повышение градиента смотрит на ошибки, а затем полностью строит новое дерево вокруг этих ошибок. Новое дерево не заботится о прогнозах, которые уже правильны.
Создание алгоритма машинного обучения, который фокусируется исключительно на ошибках, требует комплексного метода, который суммирует ошибки, чтобы сделать точные окончательные прогнозы. Этот метод использует остатки, разницу между прогнозами модели и фактическими значениями. Вот общая идея:
Повышение градиента вычисляет остатки прогнозов каждого дерева и суммирует все остатки, чтобы оценить модель.
Важно понять Вычисление и суммирование остатков Поскольку эта идея лежит в основе XGBOOST, расширенная версия повышения градиента. Когда вы создаете свою собственную версию повышения градиента, процесс вычисления и суммирования остатков станет ясным. В следующем разделе вы создадите свою собственную версию модели повышения градиента. Во -первых, давайте подробно узнаем, как работает повышение градиента.
В этом разделе мы посмотрим под капот повышения градиента и построим модель повышения градиента с нуля, обучая новые деревья об ошибках предыдущих деревьев. Ключевая математическая идея здесь остаточная. Затем мы получим те же результаты, используя алгоритм повышения градиента Scikit-Learn.
Остатки
Остатки – это разница между ошибками и прогнозами данной модели. В статистике остатки обычно анализируются, чтобы определить, насколько хороша данная модель линейной регрессии соответствует данным.
Рассмотрим следующие примеры:
Прокат велосипедов а Прогноз : 759 b. Результат : 799 в Остаточный : 799 –
Доход а Прогноз : 100 000 b. Результат : 88 000 в Остаточный : 88 000 – 100 000 = -12 000
Как вы можете видеть, остатки говорят вам, насколько далеко прогнозы модели от реальности, и они могут быть позитивными или отрицательными.
Вот визуальный пример, отображающий остатки Линейная регрессия Линия: Рисунок 1 – Остатки линии линейной регрессии
Цель линейной регрессии – минимизировать квадрат остатков. Как показывает график, изображение остатков показывает, насколько хорошо линия подходит для данных. В статистике линейный регрессионный анализ часто выполняется путем графика остатков, чтобы получить более глубокое понимание данных.
Чтобы построить алгоритм повышения градиента с нуля, мы рассчитым остатки каждого дерева и подместим новую модель к остаткам. Давайте сделаем это сейчас.
Изучение того, как создавать модели повышения градиента с нуля
Создание модели повышения градиента с нуля даст вам более глубокое понимание того, как работает повышение градиента в коде. Перед созданием модели нам необходимо получить доступ к данным и подготовить ее к машинному обучению.
Обработка набора данных об аренде велосипедов Мы продолжаем набор данных с арендной платой велосипедов, чтобы сравнить новые модели с предыдущими моделями:
1) Начнем с импорта панд и Numpy. Мы также добавим линию, чтобы заставить замолчать любые предупреждения:
import pandas as pd
import numpy as np
import warnings
warnings.filterwarnings('ignore')
2) Теперь загрузите набор данных bike_rentals_cleaned и просмотреть первые пять строк:
df_bikes = pd.read_csv('bike_rentals_cleaned.csv')
df_bikes.head()
Ваш вывод должен выглядеть следующим образом: Рисунок 2 – Первые пять рядов набора данных об аренде велосипеда
3) Теперь разделите данные на x и y. Затем разделить x и y на тренировки и наборы тестирования:
X_bikes = df_bikes.iloc[:,:-1] y_bikes = df_bikes.iloc[:,-1] from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X_ bikes, y_bikes, random_state=2)
Пришло время построить модель повышения градиента с нуля!
Создание модели повышения градиента с нуля Вот шаги по созданию модели машинного обучения по повышению градиента с нуля:
1) Установите данные к дереву решений: вы можете использовать пень дерева решений, который имеет значение max_depth 1 или дерево решений со значением MAX_DEPTH 2 или 3. Первоначальное дерево решений, называемое базовый ученик , не должно быть точным для точности. Нам нужна модель, которая фокусируется на том, чтобы учиться на ошибках, а не модели, которая в значительной степени зависит от базового учащегося. Инициализируйте дерево решений с и подходите к нему на тренировочном наборе как Tree_1, поскольку это первое дерево в нашем ансамбле:
from sklearn.tree import DecisionTreeRegressor tree_1 = DecisionTreeRegressor(max_depth=2, random_ state=2) tree_1.fit(X_train, y_train)
2) Сделайте прогнозы с учебным набором: вместо того, чтобы делать прогнозы с помощью тестового набора, прогнозы в повышении градиента изначально производятся с учебным набором. Почему? Чтобы вычислить остатки, нам необходимо сравнить прогнозы, пока все еще находятся на этапе обучения. Фаза испытаний модельной сборки происходит в конце, после того как все деревья были построены. Прогнозы учебного набора для первого раунда получены путем добавления метода прогнозирования в Tree_1 с x_train в качестве входа:
y_train_pred = tree_1.predict(X_train)
3) Вычислить остатки: остатки – это различия между прогнозами и целевым столбцом. Предсказания x_train, определенные здесь как Y_TRAIN_PRED, вычитаются из Y_TRAIN, целевого столбца, для вычисления остатков:
y2_train = y_train - y_train_pred
Примечание
Остатки определяются как y2_train, потому что они являются новым целевым столбцом для следующего дерева.
4) Установите новое дерево на остатках: Установка нового дерева на остатках отличается от подгонки модели на тренировочном наборе. Основное различие заключается в прогнозах. В наборе данных об аренде велосипедов при подгонке нового дерева на остатках мы должны постепенно получать меньшие числа.
Инициализируйте новое дерево и поместите его на x_train и остатки, y2_train:
tree_2 = DecisionTreeRegressor(max_depth=2, random_ state=2) tree_2.fit(X_train, y2_train)
5) Повторите шаги 2-4: По мере продолжения процесса остатки должны постепенно приближаться к 0 из положительного и отрицательного направления. Итерации продолжаются по количеству оценок, n_estimators.
Давайте повторим процесс для третьего дерева следующим образом:
y2_train_pred = tree_2.predict(X_train) y3_train = y2_train - y2_train_pred tree_3 = DecisionTreeRegressor(max_depth=2, random_ state=2) tree_3.fit(X_train, y3_train)
Этот процесс может продолжаться для десятков, сотен или тысяч деревьев. При нормальных обстоятельствах вы, безусловно, продолжите идти. Потребуется больше, чем несколько деревьев, чтобы превратить слабого ученика в сильного ученика. Однако, поскольку наша цель состоит в том, чтобы понять, как работает повышение градиента за кулисами, мы будем двигаться дальше, когда общая идея была покрыта.
6) Сумма результатов: суммирование результатов требует прогнозирования для каждого дерева с помощью набора тестов следующим образом:
y1_pred = tree_1.predict(X_test) y2_pred = tree_2.predict(X_test) y3_pred = tree_3.predict(X_test)
Поскольку прогнозы являются положительными и отрицательными различиями, суммирование прогнозов должно привести к прогнозам, которые ближе к целевому столбцу следующим образом:
y_pred = y1_pred + y2_pred + y3_pred
7) Наконец, давайте вычислим средняя квадратная ошибка (MSE) Чтобы получить результаты следующим образом:
from sklearn.metrics import mean_squared_error as MSE MSE(y_test, y_pred)**0.5
Вот ожидаемый выход:
911.0479538776444
Неплохо для слабого ученика, который еще не силен! Теперь давайте попробуем получить тот же результат, используя Scikit-Learn.
Создание модели повышения градиента в Scikit-Learn
Давайте посмотрим, сможем ли мы получить тот же результат, что и в предыдущем разделе, используя GradientBoostingResor’s Scikit-Learn. Это может быть сделано с помощью нескольких корректировок гиперпараметра. Преимущество использования GradientBoostingregresressor заключается в том, что его гораздо быстрее создавать и легче реализовать:
1) Во -первых, импортируйте регрессор из библиотеки Sklearn.ensemble:
from sklearn.ensemble import GradientBoostingRegressor
2) При инициализации Gradientboostingregressor, есть несколько важных гиперпараметров. Чтобы получить те же результаты, важно соответствовать и. Кроме того, поскольку мы должны иметь только три деревья. Наконец, мы должны установить гиперпараметр.0. В ближайшее время мы будем многое сказать об обучении_рэта:
gbr = GradientBoostingRegressor(max_depth=2, n_ estimators=3, random_state=2, learning_rate=1.0)
3) Теперь, когда модель была инициализирована, она может быть вписывается в учебные данные и оценена по данным тестирования:
gbr.fit(X_train, y_train) y_pred = gbr.predict(X_test) MSE(y_test, y_pred)**0.5
Результат заключается в следующем:
911.0479538776439
Результат такой же до 11 десятичных десятичных мест!
Напомним, что смысл повышения градиента состоит в том, чтобы построить модель с достаточным количеством деревьев, чтобы превратить слабого ученика в сильного ученика. Это легко сделать путем изменения N_ESTIMATORS, количество итераций, на гораздо большее число.
4) Давайте построим и выиграем регрессор повышения градиента с 30 оценщиками:
gbr = GradientBoostingRegressor(max_depth=2, n_ estimators=30, random_state=2, learning_rate=1.0) gbr.fit(X_train, y_train) y_pred = gbr.predict(X_test) MSE(y_test, y_pred)**0.5
Результат заключается в следующем:
857.1072323426944
Оценка – улучшение. Теперь давайте посмотрим на 300 оценок:
gbr = GradientBoostingRegressor(max_depth=2, n_ estimators=300, random_state=2, learning_rate=1.0) gbr.fit(X_train, y_train) y_pred = gbr.predict(X_test) MSE(y_test, y_pred)**0.5
Результат такова:
936.3617413678853
Это сюрприз! Счет стал хуже! Нас ввели в заблуждение? Является ли повышение градиента, не все, чем он взломан?
Всякий раз, когда вы получаете неожиданный результат, это стоит двойной проверки кода. Теперь мы изменили Learning_Rate, не сказав об этом. Итак, что произойдет, если мы удалимся. 0 и используем по умолчанию Scikit-Learn?
Давай выясним:
gbr = GradientBoostingRegressor(max_depth=2, n_estimators=300, random_state=2) gbr.fit(X_train, y_train) y_pred = gbr.predict(X_test) MSE(y_test, y_pred)**0.5
Результат такова:
653.7456840231495
Невероятный! Используя дефолт Scikit-Learn для гиперпараметра Learning_Rate, оценка изменилась с 936 до 654.
В следующем разделе мы узнаем больше о различных градиентных повышении гиперпараметров с акцентом на гиперпараметр Learning_Rate.
В этом разделе мы сосредоточимся на Learning_Rate, наиболее важном гиперпараметре, повышающем градиент, за возможным исключением N_ESTIMATORS, количество итераций или деревьев в модели. Мы также рассмотрим некоторые гиперпараметры деревьев и подвыборки, что приводит к Стохастическое повышение градиента Анкет Кроме того, мы будем использовать RandomizedSearchCV и сравнить результаты с XGBOOST.
Learning_Rate
В последнем разделе изменение значения Learning_Rate GradientBoostingregresress с 1,0 на дефолт Scikit-Learn, который составляет 0,1, что привело к огромным достижениям.
Learning_Rate, также известный как усадка , сокращает вклад отдельных деревьев, так что ни одно дерево не оказывает слишком большого влияния при построении модели. Если весь ансамбль построен из ошибок одного базового учащегося, без тщательной корректировки гиперпараметров, ранние деревья в модели могут оказать слишком большое влияние на последующее развитие. Learning_Rate ограничивает влияние отдельных деревьев. Вообще говоря, как n_estimators, количество деревьев, увеличивается, Learning_Rate должно идти вниз.
Определение оптимального значения Learning_Rate требует различных N_ESTIMATORS. Во -первых, давайте удержим N_ESTIMATORS и посмотрим, что делает Learning_Rate самостоятельно. Learning_Rate колеблется от 0 до 1. Значение Learning_Rate 1 означает, что корректировки не внесены. Значение по умолчанию 0,1 означает, что влияние дерева взвешивается на 10%.
Вот разумный диапазон для начала:
Learning_Rate_values = [0,001, 0,01, 0,05, 0,1, 0,15, 0,2, 0,3, 0,5, 1,0]
Далее мы рассмотрим ценности, создав и забив новый градиентбустригрессор, чтобы увидеть, как сравниваются результаты:
for value in learning_rate_values:
gbr = GradientBoostingRegressor(max_depth=2, n_
estimators=300, random_state=2, learning_rate=value)
gbr.fit(X_train, y_train)
y_pred = gbr.predict(X_test)
rmse = MSE(y_test, y_pred)**0.5
print('Learning Rate:', value, ', Score:', rmse)
Значения и оценки курса обучения следующие:
Learning Rate: 0.001 , Score: 1633.0261400367258 Learning Rate: 0.01 , Score: 831.5430182728547 Learning Rate: 0.05 , Score: 685.0192988749717 Learning Rate: 0.1 , Score: 653.7456840231495 Learning Rate: 0.15 , Score: 687.666134269379 Learning Rate: 0.2 , Score: 664.312804425697 Learning Rate: 0.3 , Score: 689.4190385930236 Learning Rate: 0.5 , Score: 693.8856905068778 Learning Rate: 1.0 , Score: 936.3617413678853
Как вы можете видеть из вывода, значение Learning_Rate по умолчанию 0,1 дает лучший результат для 300 деревьев.
Теперь давайте изменяем n_estimators. Используя предыдущий код, мы можем генерировать графики Learning_Rate с n_estimators из 30, 300 и 3000 деревьев, как показано на следующем рисунке: Рисунок 3 – Учебный план.
Как вы можете видеть, с 30 деревьями значение Learning_Rate достигает пика около 0,3.
Теперь давайте посмотрим на участок Learning_Rate для 3000 деревьев: Рисунок 4 – Учебный план Learning_Rate для 3000 деревьев
С 3000 деревьев значение Learning_Rate достигает пика во втором значении, которое дано 0,05.
Эти графики подчеркивают важность настройки Learning_Rate и N_ESTIMATORS вместе.
Базовый ученик
Первоначальное дерево решений в регрессоре повышения градиента называется базовый ученик Потому что это у основания ансамбля. Это первый учащийся в процессе. Термин ученик Вот свидетельствует о Слабый ученик превращение в сильный ученик .
Хотя ученики базы не должны быть хорошими для точности, конечно, можно настроить учеников базовых на точность.
Например, мы можем выбрать значение max_depth 1, 2, 3 или 4 и сравнить результаты следующим образом:
depths = [None, 1, 2, 3, 4]
for depth in depths:
gbr = GradientBoostingRegressor(max_depth=depth, n_
estimators=300, random_state=2)
gbr.fit(X_train, y_train)
y_pred = gbr.predict(X_test)
rmse = MSE(y_test, y_pred)**0.5
print('Max Depth:', depth, ', Score:', rmse)
depths = [None, 1, 2, 3, 4]
for depth in depths:
gbr = GradientBoostingRegressor(max_depth=depth, n_
estimators=300, random_state=2)
gbr.fit(X_train, y_train)
y_pred = gbr.predict(X_test)
rmse = MSE(y_test, y_pred)**0.5
print('Max Depth:', depth, ', Score:', rmse)
Результат заключается в следующем:
Max Depth: None , Score: 867.9366621617327 Max Depth: 1 , Score: 707.8261886858736 Max Depth: 2 , Score: 653.7456840231495 Max Depth: 3 , Score: 646.4045923317708 Max Depth: 4 , Score: 663.048387855927
Значение max_depth 3 дает лучшие результаты.
Другие базовые гиперпараметры могут быть настроены аналогичным образом.
подвыборка
Подвыборка представляет собой подмножество образцов. Поскольку образцы являются рядами, подмножество рядов означает, что все строки могут не включаться при строительстве каждого дерева. Изменив выборку с 1,0 на меньшее десятичное значение, деревья выбирают только процент образцов во время фазы сборки. Например, .8 выберет 80% образцов для каждого дерева.
Продолжая, мы пробуем ряд процентов выборки для улучшения результатов:
samples = [1, 0.9, 0.8, 0.7, 0.6, 0.5]
for sample in samples:
gbr = GradientBoostingRegressor(max_depth=3, n_
estimators=300, subsample=sample, random_state=2)
gbr.fit(X_train, y_train)
y_pred = gbr.predict(X_test)
rmse = MSE(y_test, y_pred)**0.5
print('Subsample:', sample, ', Score:', rmse)
Результат заключается в следующем:
Subsample: 1 , Score: 646.4045923317708 Subsample: 0.9 , Score: 620.1819001443569 Subsample: 0.8 , Score: 617.2355650565677 Subsample: 0.7 , Score: 612.9879156983139 Subsample: 0.6 , Score: 622.6385116402317 Subsample: 0.5 , Score: 626.9974073227554
Значение подвыборки 0,7 с 300 деревьями и max_depth 3 дает лучший результат.
Когда подвыборка не равна 1.0, модель классифицируется как Стохастический градиент спуск , где Стохастичный Указывает, что некоторая случайность присущ в модели.
Рандомизированная сторона исследования
У нас хорошая рабочая модель, но мы еще не выполнили поиск в сетке. Наш предварительный анализ указывает на то, что поиск сетки сосредоточен вокруг, .7 ,, и.1 – хорошее место для начала. Мы уже показали, что по мере того, как n_estimators поднимается, Learning_Rate должен идти вниз:
1) Вот возможная отправная точка:
params={'subsample':[0.65, 0.7, 0.75],
'n_estimators':[300, 500, 1000],
'learning_rate':[0.05, 0.075, 0.1]}
Поскольку n_estimators выходит из начального значения 300, Learning_Rate снижается от начального значения 0,1. Давайте будем ограничивать дисперсию.
Благодаря 27 возможным комбинациям гиперпараметров мы используем рандомизированный SearchCV, чтобы попробовать 10 из этих комбинаций в надежде найти хорошую модель.
Примечание
В то время как 27 комбинаций осуществимы с GridsearchCV, в какой -то момент вы получите слишком много возможностей, и рандомизированный SearchCV станет необходимым. Мы используем RandomizedSearchCV здесь для практики и для ускорения вычислений.
2) Давайте импортируем рандомизированные данные и инициализируем модель повышения градиента:
from sklearn.model_selection import RandomizedSearchCV gbr = GradientBoostingRegressor(max_depth=3, random_ state=2)
3) Далее инициализируйте рандомизированное searchcv с GBR и Params в качестве входов в дополнение к количеству итераций, оценки и количества складок. Напомним, что n_jobs = -1 может ускорить вычисления и обеспечивает согласованность результатов:
rand_reg = RandomizedSearchCV(gbr, params, n_iter=10, scoring='neg_mean_squared_error', cv=5, n_jobs=-1, random_state=2)
4) Теперь вписывайте модель на учебном наборе и получите лучшие параметры и оценки:
rand_reg.fit(X_train, y_train)
best_model = rand_reg.best_estimator_
best_params = rand_reg.best_params_
print("Best params:", best_params)
best_score = np.sqrt(-rand_reg.best_score_)
print("Training score: {:.3f}".format(best_score))
y_pred = best_model.predict(X_test)
rmse_test = MSE(y_test, y_pred)**0.5
print('Test set score: {:.3f}'.format(rmse_test))
Результат заключается в следующем:
Best params: {'learning_rate': 0.05, 'n_estimators': 300,
'subsample': 0.65}
Training score: 636.200
Test set score: 625.985
Отсюда стоит экспериментировать, изменяя параметры индивидуально или в парах. Несмотря на то, что лучшая модель в настоящее время имеет, вполне возможно, что повышение этого гиперпараметра получит лучшие результаты с тщательной корректировкой значения Learning_Rate. Смень также может быть экспериментирована.
5) После нескольких раундов экспериментов мы получили следующую модель:
gbr = GradientBoostingRegressor(max_depth=3, n_ estimators=1600, subsample=0.75, learning_rate=0.02, random_state=2) gbr.fit(X_train, y_train) y_pred = gbr.predict(X_test) MSE(y_test, y_pred)**0.5
Результат – следующее:
596.9544588974487
При большем значении для n_estimators на 1600, меньшее значение Learning_Rate при 0,02, сопоставимое значение подвыборки 0,75 и то же самое значение MAX_DEPTH 3, мы получили лучшее Средняя квадратная ошибка (RMSE) но в 597.
Может быть возможно лучше. Мы призываем вас попробовать!
Теперь давайте посмотрим, как XGBOOST отличается от повышения градиента, используя те же гиперпараметры, которые охватывали до сих пор.
XGBOOST
XGBOOST – это продвинутая версия повышения градиента с той же общей структурой, что означает, что она превращает слабых учеников в сильных учеников, подводя подводной подводной основания остатки деревьев.
Единственная разница в гиперпараметрах из последнего раздела заключается в том, что XGBOOST относится к Learning_Rate как ETA.
Давайте построим XGBOOST -регрессор с теми же гиперпараметрами, чтобы сравнить результаты.
Импортируйте XGBRERSORSOR с XGBOOST, а затем инициализируйте и оцените модель следующим образом:
from xgboost import XGBRegressor xg_reg = XGBRegressor(max_depth=3, n_estimators=1600, eta=0.02, subsample=0.75, random_state=2) xg_reg.fit(X_train, y_train) y_pred = xg_reg.predict(X_test) MSE(y_test, y_pred)**0.5
Результат такова:
584.339544309016
Счет лучше.
Точность и скорость являются двумя наиболее важными понятиями при создании моделей машинного обучения, и мы несколько раз показали, что XGBOOST очень точен. XGBOOST предпочтительнее повышения градиента в целом, потому что он последовательно дает лучшие результаты и потому, что он быстрее, как продемонстрировано следующим тематическим исследованием.
В реальном мире наборы данных могут быть огромными, с триллионами точек данных. Ограничение работы на одном компьютере может быть невыгодным из -за ограниченных ресурсов одной машины. При работе с большими данными облако часто используется для использования параллельных компьютеров.
Наборы данных большие, когда они раздвигают пределы вычислений. В этом разделе мы осматриваем экзопланеты со временем. Набор данных имеет 5 087 строк и 3189 столбцов, которые записывают поток света в разное время жизненного цикла звезды. Умножение столбцов и строк вместе приводит к 1,5 миллионам данных. Используя базовую линию 100 деревьев, нам нужно 150 миллионов точек данных для построения модели.
В этом разделе у моего MacBook Air 2013 года было время ожидания около 5 минут. Новые компьютеры должны быть быстрее. Я выбрал набор данных Exoplanet, так что время ожидания играет значительную роль, не завязывая ваш компьютер в течение очень долгого времени.
Представление набора данных экзопланета
Набор данных Exoplanet взят из Kaggle и датируется около 2017 года: https://www.kaggle.com/keplersmachines/kepler-labelled-time-series-data . Набор данных содержит информацию о свете звезд. Каждая строка является отдельной звездой, и столбцы раскрывают разные световые узоры с течением времени. В дополнение к световым рисункам, колонка экзопланета помечена 2, если звезда проводит экзопланету; В противном случае он помечен 1.
Набор данных записывает световой поток от тысяч звезд. Легкий поток , часто называют Светящий поток , это воспринимаемая яркость звезды.
Примечание
Воспринимаемая яркость отличается от фактической яркости. Например, невероятно яркая звезда очень далеко может иметь небольшой светящийся поток (выглядит тусклым), в то время как умеренно яркая звезда, которая очень близко, как солнце, может иметь большой светящийся поток (выглядит ярко).
Когда световой поток отдельной звезды периодически меняется, возможно, что звезда вращается экзопланетой. Предполагается, что когда экзопланета вращается перед звездой, она блокирует небольшую долю света, уменьшая воспринимаемую яркость на очень небольшое количество.
Кончик
Поиск экзопланеты встречается редко. В предсказательном столбце, о том, проводит ли звезда экзопланета или нет, имеет очень мало положительных случаев, что приводит к несбалансированному набору данных. Несбалансированные наборы данных требуют дополнительных мер предосторожности.
Далее, давайте получить доступ к набору данных Exoplanet и подготовим его для машинного обучения.
Предварительная обработка набора данных Exoplanet
Набор данных Exoplanet был загружен на нашу страницу Github AT https://github.com/packtpublishing/hands-on-gradient-boosting-with-xgboost-and-scikit-learn/tree/master/chapter04 Анкет
Вот шаги по загрузке и предварительной обработке набора данных Exoplanet для машинного обучения:
1) Загрузите exoplanets.csv в той же папке, что и ноутбук Jupyter. Затем откройте файл и посмотрите:
df = pd.read_csv('exoplanets.csv')
df.head()
DataFrame будет выглядеть как показано на следующем рисунке: Рисунок 5 – Exoplanet DataFrame
Не все столбцы показаны из -за ограничений пространства. Колонны Flux-это поплавки, а колонна метки-2 для звезды экзопланеты и 1 для не экзопланетной звезды.
2) Давайте подтвердим, что все столбцы численны с df.info ():
df.info()
Результат заключается в следующем:
RangeIndex: 5087 entries, 0 to 5086 Columns: 3198 entries, LABEL to FLUX.3197 dtypes: float64(3197), int64(1) memory usage: 124.1 MB
Как вы можете видеть из вывода, столбцы 3197 являются поплавками, а 1 столбец – это int, поэтому все столбцы являются численными.
3) Теперь давайте подтвердим количество нулевых значений со следующим кодом:
df.isnull().sum().sum()
Вывод заключается в следующем:
0
Вывод показывает, что нет нулевых значений.
4) Поскольку все столбцы являются численными без нулевых значений, мы можем разделить данные на обучающие и испытательные наборы. Обратите внимание, что 0 -я столбец – это столбец целевого, Y, а все остальные столбцы являются столбцами предиктора, x:
X = df.iloc[:,1:] y = df.iloc[:,0] X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=2)
Пришло время построить классификатор повышения градиента, чтобы предсказать, принимают ли звезды экзопланеты.
Строительство повышения классификаторов
Градиентные повышения классификаторов работают так же, как регрессоры повышения градиента. Разница в основном в оценке.
Давайте начнем с импорта GradientBoostingClassifer и XGBClassifier в дополнение к точности_SCORE, чтобы мы могли сравнить обе модели:
from sklearn.ensemble import GradientBoostingClassifier from xgboost import XGBClassifier from sklearn.metrics import accuracy_score
Затем нам нужен способ сравнения моделей с использованием таймера.
Время модели
Python поставляется с библиотекой времени, которую можно использовать, чтобы отметить время. Общая идея состоит в том, чтобы отметить время до и после вычисления. Разница между этим временем говорит нам, как долго проходили вычисление.
Библиотека времени импортируется следующим образом:
import time
В библиотеке времени метод .time () знаменует собой время за считанные секунды.
В качестве примера, посмотрите, сколько времени требуется, чтобы запустить df.info (), назначив время начала и окончания до и после вычисления с использованием time.time ():
start = time.time()
df.info()
end = time.time()
elapsed = end - start
print('\nRun Time: ' + str(elapsed) + ' seconds.')
Вывод заключается в следующем:
RangeIndex: 5087 entries, 0 to 5086 Columns: 3198 entries, LABEL to FLUX.3197 dtypes: float64(3197), int64(1) memory usage: 124.1 MB
Средство выполнения следующее:
Run Time: 0.0525362491607666 seconds.
Ваши результаты будут отличаться от наших, но, надеюсь, это на том же стадии.
Теперь давайте сравним GradientBoostingClassifier и XgboostClassifier с набором данных Exoplanet для его скорости, используя предыдущий код, чтобы отметить время.
Кончик
Ноутбуки Jupyter поставляются с магическими функциями, обозначенными знаком % до команды. %timeit – одна из таких волшебных функций. Вместо того, чтобы вычислять, сколько времени требуется, чтобы запустить код один раз, %timeit Смотрите https://ipython.readthedocs.io/en/stable/interactive/magics.html Для получения дополнительной информации о волшебных функциях.
Сравнивая скорость
Пришло время участвовать в гонке GradientBoostingClassifier и XGBoostClassifier с набором данных Exoplanet. Мы установили и ограничивают размер модели. Начнем с GradientBoostingClassifier:
1) Во -первых, мы отметим время начала. После строительства и забивания модели мы отметим время окончания. Следующий код может занять около 5 минут в зависимости от скорости вашего компьютера:
start = time.time()
gbr = GradientBoostingClassifier(n_estimators=100, max_
depth=2, random_state=2)
gbr.fit(X_train, y_train)
y_pred = gbr.predict(X_test)
score = accuracy_score(y_pred, y_test)
print('Score: ' + str(score))
end = time.time()
elapsed = end - start
print('\nRun Time: ' + str(elapsed) + ' seconds')
Результат такова:
Score: 0.9874213836477987 Run Time: 317.6318619251251 seconds
Gradientboostingregresress потребовался более 5 минут, чтобы запустить мой Macbook Air 2013 года. Неплохо для 150 миллионов точек данных на старом компьютере.
Примечание
Хотя балл 98,7%, как правило, является непогашенным для точности, это не относится к несбалансированным наборам данных.
2) Далее мы построим модель XGBClassifier с одинаковыми гиперпараметрами и отметим время таким же образом:
start = time.time()
xg_reg = XGBClassifier(n_estimators=100, max_depth=2,
random_state=2)
xg_reg.fit(X_train, y_train)
y_pred = xg_reg.predict(X_test)
score = accuracy_score(y_pred, y_test)
print('Score: ' + str(score))
end = time.time()
elapsed = end - start
print('Run Time: ' + str(elapsed) + ' seconds')
Результат заключается в следующем:
Score: 0.9913522012578616 Run Time: 118.90568995475769 seconds
На моем MacBook Air 2013 года XGBOOST занял менее 2 минут, что делает его более чем в два раза быстрее. Это также более точное на пол процента.
Когда дело доходит до больших данных, алгоритм вдвое быстрее может сэкономить недели или месяцы вычислительного времени и ресурсов. Это преимущество огромно в мире больших данных.
В мире повышения XGBOOST является моделью выбора из -за его беспрецедентной скорости и впечатляющей точности.
Примечание
Недавно я приобрел 2020 MacBook Pro и обновил все программное обеспечение. Разница во времени с использованием того же кода ошеломляет:
Градиент повышение времени работы: 197,38 секунды
XGBOOST Время выполнения: 8,66 секунды
Больше, чем в 10-кратном разнице!
В этой статье вы узнали разницу между мешками и повышением. Вы узнали, как работает повышение градиента, создавая регрессор повышения градиента с нуля. Вы реализовали различные гиперпараметры повышения градиента, в том числе Learning_Rate, N_ESTIMATORS, MAX_DEPTH и подвыборки, что приводит к повышению стохастического градиента. Наконец, вы использовали большие данные, чтобы предсказать, имеют ли звезды экзопланеты, сравнивая время градиентбустенгасификатора и Xgboostclassifier, причем xgboostclassifier появляется в два раза до в десять раз и точнее.
Преимущество изучения этих навыков заключается в том, что вы теперь понимаете, когда применять XGBOOST, а не аналогичные алгоритмы машинного обучения, такие как повышение градиента. Теперь вы можете создать более сильные модели XGBOOST и повышение градиента, правильно используя основные гиперпараметры, включая N_ESTIMATORS и Learning_Rate. Кроме того, вы разработали способность к временю всех вычислений, а не полагаться на интуицию.
Узнайте, как создавать мощные модели XGBOOST с помощью Python и Sci-Kit Learn and Discover Expert Insights от Xgboost Kaggle Masters в книге Кори Уэйда Практическое повышение градиента с XGBOOST Анкет
Оригинал: “https://dev.to/packt/from-gradient-boosting-to-xgboost-2ba2”