Техники ансамблевого обучения обзор Random Forest в Python

Обзор Random Forest в Python

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

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

К концу этой статьи вы получите полное представление об ансамблевом обучении и о том, как работает случайный лес в Python. Поэтому, будь вы опытным ученым-данным или просто любопытным в расширении своих навыков машинного обучения, присоединяйтесь к нам в этом приключении и продвигайте свои навыки машинного обучения!

 

1. Что такое ансамблевое обучение?

 

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

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

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

 

2. Когда использовать ансамблевое обучение?

 

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

 

3. Стратегии ансамблевого обучения

 

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

  1. Бэггинг: Бэггинг, что является сокращением от bootstrap aggregation, является стратегией ансамблевого обучения, при которой модели обучаются с использованием случайных выборок из набора данных.
  2. Стэкинг: Стэкинг, что является сокращением от stacked generalization, является стратегией ансамблевого обучения, при которой мы обучаем модель для объединения нескольких моделей, обученных на наших данных.
  3. Бустинг: Бустинг – это техника ансамблевого обучения, которая фокусируется на выборе неправильно классифицированных данных для обучения моделей.

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

 

4. Бэггинг ансамблевого обучения

 

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

Этот подход включает в себя:

  1. Разделение исходного набора данных на несколько поднаборов с повторением.
  2. Создание базовых моделей для каждого из этих поднаборов.
  3. Параллельное выполнение всех моделей перед выполнением всех предсказаний для получения окончательных предсказаний.

Scikit-learn предоставляет нам возможность реализовать как BaggingClassifier, так и BaggingRegressor. BaggingMetaEstimator идентифицирует случайные поднаборы исходного набора данных для подгонки каждой базовой модели, а затем агрегирует отдельные прогнозы базовых моделей – либо путем голосования, либо путем усреднения – в окончательный прогноз, путем агрегирования отдельных прогнозов базовых моделей в агрегированный прогноз с использованием голосования или усреднения. Этот метод снижает дисперсию путем случайного процесса их создания.

Давайте рассмотрим пример, в котором мы используем бэггинг-оценщик с помощью scikit-learn:

от sklearn.ensemble импортируем BaggingClassifier
от sklearn.tree импортируем DecisionTreeClassifier
bagging = BaggingClassifier(base_estimator=DecisionTreeClassifier(),n_estimators=10, max_samples=0.5, max_features=0.5)

 

Классификатор Bagging принимает во внимание несколько параметров:

  • base_estimator: Базовая модель, используемая в подходе Bagging. В данном случае мы используем классификатор дерева решений.
  • n_estimators: Количество оценщиков, которое мы будем использовать в подходе Bagging. 
  • max_samples: Количество выборок, которые будут взяты из обучающего набора данных для каждого базового оценщика.
  • max_features: Количество признаков, которые будут использоваться для обучения каждого базового оценщика.

Теперь мы применим этот классификатор к обучающему набору данных и оценим его.

bagging.fit(X_train, y_train)
bagging.score(X_test,y_test)

 

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

от sklearn.ensemble импортируем BaggingRegressor
bagging = BaggingRegressor(DecisionTreeRegressor())
bagging.fit(X_train, y_train)
model.score(X_test,y_test)

 

5. Стекинг ансамблевого обучения

 

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

   

Стекинг происходит в следующих этапах:

  1. Разделите данные на обучающий и проверочный наборы
  2. Разделите обучающий набор на K блоков
  3. Обучите базовую модель на k-1 блоках и сделайте прогнозы на k-м блоке
  4. Повторяйте до тех пор, пока у вас не будет прогноза для каждого блока
  5. Обучите базовую модель на всем обучающем наборе
  6. Используйте модель для создания прогнозов на тестовом наборе
  7. Повторяйте шаги 3–6 для других базовых моделей 
  8. Используйте прогнозы с тестового набора данных в качестве признаков для новой модели (мета-модель)
  9. Сделайте окончательные прогнозы на тестовом наборе, используя мета-модель

В этом примере ниже мы начинаем с создания двух базовых классификаторов (RandomForestClassifier и GradientBoostingClassifier) и одного мета-классификатора (LogisticRegression) и используем перекрестную проверку K-блоков, чтобы использовать прогнозы от этих классификаторов на обучающих данных (набор данных iris) как входные признаки для нашего мета-классификатора (LogisticRegression). 

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

# Загрузка набора данных
data = load_iris()
X, y = data.data, data.target

# Разделение данных на обучающий и тестовый наборы
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Определение базовых классификаторов
base_classifiers = [
   RandomForestClassifier(n_estimators=100, random_state=42),
   GradientBoostingClassifier(n_estimators=100, random_state=42)
]

# Определение мета-классификатора
meta_classifier = LogisticRegression()

# Создание массива для хранения прогнозов от базовых классификаторов
base_classifier_predictions = np.zeros((len(X_train), len(base_classifiers)))

# Выполнение стекинга с использованием перекрестной проверки K-блоков
kf = KFold(n_splits=5, shuffle=True, random_state=42)
for train_index, val_index in kf.split(X_train):
   train_fold, val_fold = X_train[train_index], X_train[val_index]
   train_target, val_target = y_train[train_index], y_train[val_index]

   for i, clf in enumerate(base_classifiers):
       cloned_clf = clone(clf)
       cloned_clf.fit(train_fold, train_target)
       base_classifier_predictions[val_index, i] = cloned_clf.predict(val_fold)

# Обучение мета-классификатора на прогнозах базовых классификаторов
meta_classifier.fit(base_classifier_predictions, y_train)

# Создание прогнозов с использованием стекинга
stacked_predictions = np.zeros((len(X_test), len(base_classifiers)))
for i, clf in enumerate(base_classifiers):
   stacked_predictions[:, i] = clf.predict(X_test)

# Создание окончательных прогнозов с использованием мета-классификатора
final_predictions = meta_classifier.predict(stacked_predictions)

# Оценка точности стекинга
accuracy = accuracy_score(y_test, final_predictions)
print(f"Точность стекинга: {accuracy:.2f}")

 

6. Усиление ансамбля в машинном обучении

 

Усиление (boosting) – это техника ансамблевого обучения в машинном обучении, которая уменьшает смещение и разброс путем превращения слабых обучающихся в сильных. Эти слабые обучающиеся применяются последовательно к набору данных: сначала создается начальная модель и подгоняется к обучающему набору. После того, как ошибки первой модели были выявлены, создается еще одна модель для их исправления.

Есть популярные алгоритмы и реализации для усиления ансамбля в машинном обучении. Давайте рассмотрим наиболее известные из них. 

 

6.1. AdaBoost

 

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

AdaBoost – это универсальный алгоритм, подходящий как для задач регрессии, так и для задач классификации, но здесь мы сосредоточимся на его применении к задачам классификации с использованием библиотеки Scikit-learn. Давайте посмотрим, как мы можем использовать его для задач классификации в приведенном ниже примере:

from sklearn.ensemble import AdaBoostClassifier
model = AdaBoostClassifier(n_estimators=100)
model.fit(X_train, y_train)
model.score(X_test,y_test)

 

В этом примере мы использовали AdaBoostClassifier из библиотеки scikit-learn и установили n_estimators равным 100. По умолчанию используется дерево решений, и вы можете его изменить. Кроме того, можно настроить параметры дерева решений.

 

2. Экстремальное градиентное усиление (XGBoost)

 

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

import xgboost as xgb
params = {"objective":"binary:logistic",'colsample_bytree': 0.3,'learning_rate': 0.1,
               'max_depth': 5, 'alpha': 10}
model = xgb.XGBClassifier(**params)
model.fit(X_train, y_train)
model.fit(X_train, y_train)
model.score(X_test,y_test)

 

3. LightGBM

 

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

   

В приведенном ниже примере мы применим LightGBM к задаче бинарной классификации:

import lightgbm as lgb
lgb_train = lgb.Dataset(X_train, y_train)
lgb_eval = lgb.Dataset(X_test, y_test, reference=lgb_train)
params = {'boosting_type': 'gbdt',
             'objective': 'binary',
             'num_leaves': 40,
             'learning_rate': 0.1,
             'feature_fraction': 0.9
             }
gbm = lgb.train(params,
   lgb_train,
   num_boost_round=200,
   valid_sets=[lgb_train, lgb_eval],
   valid_names=['train','valid'],
  )

 

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

 

Ссылки 

 

  • Введение в алгоритмы ансамблевого обучения
  • Полное руководство по ансамблевому обучению: что именно нужно знать
  • Полное руководство по ансамблевому обучению (с примерами на Python)

    Юссеф Рафаат – исследователь компьютерного зрения и специалист по обработке данных. Его исследования сосредоточены на разработке алгоритмов компьютерного зрения в реальном времени для медицинских приложений. Он также работал в качестве специалиста по обработке данных более 3 лет в сферах маркетинга, финансов и здравоохранения.