Уроки Kaggle: сравнивайте алгоритмы ансамблей с точки зрения точности модели, надежности и обобщения. Реализация включена!
Вступление
Мы ранее обсуждали некоторые из распространенных способов использования возможностей прогнозирования моделей машинного обучения (ML). Эти методы в основном используются для улучшения обобщаемости модели путем разделения данных на конкретные схемы.
Однако существуют более продвинутые методы повышения производительности моделей, такие как ансамблевые алгоритмы. В этом посте мы обсудим и сравним производительность нескольких ансамблевых алгоритмов. Итак, приступим!
Метод ансамбля нацелен на объединение прогнозов нескольких базовых оценок вместо одной оценки, которые усиливают обобщение и надежность модели.
Обновление 13.02.2021: включите ссылку на класс StackingClassifier () в модуль sklearn.ensemble.
Предварительные условия
- Я буду использовать набор данных игрушек из публичного репозитория UCIML, который размещен на Kaggle; Он состоит из девяти столбцов, включая целевую переменную. Блокнот размещен на GitHub, если вы хотите продолжить.
- Я использовал Kaggle API для получения набора данных во время работы с записной книжкой. Если у вас нет учетной записи на Kaggle, просто загрузите набор данных на свой локальный компьютер и пропустите эту часть в записной книжке. Вы можете следить за этой публикацией в StackOverflow for step-by-step инструкциях.
Я включил сценарий для получения и загрузки данных в Google Colab, просто убедитесь, что вы создали свой собственный токен перед его запуском.
3. Я выполнил базовую предварительную обработку набора данных перед построением модели - например, ввел недостающие данные, чтобы избежать ошибок.
4. Я создал две отдельные тетради, одну для сравнения первых трех ансамблей. Второй - реализация стекированного ансамбля с нуля и с использованием библиотеки MLens.
Методы ансамблей
Ансамбли - это процедуры, которые создают различные модели, а затем смешивают их для получения улучшенных прогнозов. Ансамбли позволяют получать более точные прогнозы по сравнению с одной моделью. Использование ансамблей обычно давало преимущество командам-победителям в соревнованиях по ML. Вы можете найти интервью победителей CrowdFlower - Team Quartet, которые использовали Ensemble для победы в конкурсе.
1. Бэггинг - агрегирование начальной загрузки:
B ootstrap agg regat ing имеет тенденцию создавать несколько моделей (с использованием одного и того же типа алгоритмов) из разных подвыборок с заменой из набора обучающих данных.
Бэггинг заключается в объединении нескольких хороших моделей, чтобы уменьшить дисперсию модели.
Бэггинг имеет три типа ансамблей:
1.2 Деревья решений по упаковке
Бэггинг лучше всего работает с алгоритмами, которые производят прогнозы с высокой дисперсией. В следующем примере мы разработаем BaggingClassifier () в сочетании с DecisionTreeClassifier () в библиотеке sklearn.
Обратите внимание, что результаты могут отличаться из-за природы стохастического обучения!
Бэггинг производит модели и параллельно разделяет образцы.
from sklearn.ensemble import BaggingClassifier
tree = DecisionTreeClassifier()
bagging_clf = BaggingClassifier(base_estimator=tree, n_estimators=1500, random_state=42)
bagging_clf.fit(X_train, y_train)
evaluate(bagging_clf, X_train, X_test, y_train, y_test)
TRAINIG RESULTS:
===============================
CONFUSION MATRIX:
[[350 0]
[ 0 187]]
ACCURACY SCORE:
1.0000
CLASSIFICATION REPORT:
0 1 accuracy macro avg weighted avg
precision 1.0 1.0 1.0 1.0 1.0
recall 1.0 1.0 1.0 1.0 1.0
f1-score 1.0 1.0 1.0 1.0 1.0
support 350.0 187.0 1.0 537.0 537.0
TESTING RESULTS:
===============================
CONFUSION MATRIX:
[[126 24]
[ 38 43]]
ACCURACY SCORE:
0.7316
CLASSIFICATION REPORT:
0 1 accuracy macro avg weighted avg
precision 0.768293 0.641791 0.731602 0.705042 0.723935
recall 0.840000 0.530864 0.731602 0.685432 0.731602
f1-score 0.802548 0.581081 0.731602 0.691814 0.724891
support 150.000000 81.000000 0.731602 231.000000 231.000000
1.2 Случайный лес (РФ)
Случайный лес (RF) - это метаоценка, которая соответствует различным классификаторам дерева решений на нескольких подвыборках и оценивает среднюю точность.
Размер подвыборки является постоянным, но образцы рисуются с заменой, если bootstrap = True (по умолчанию).
Теперь давайте сделаем снимок и попробуем модель случайного леса (RF). RF работает как класс дерева решений в пакетах; однако это снижает корреляцию между отдельными классификаторами. RF учитывает только случайное подмножество функций на разбиение вместо того, чтобы следовать жадному подходу к выбору наилучшей точки разделения.
from sklearn.ensemble import RandomForestClassifier
rf_clf = RandomForestClassifier(random_state=42, n_estimators=1000)
rf_clf.fit(X_train, y_train)
evaluate(rf_clf, X_train, X_test, y_train, y_test)
TRAINIG RESULTS:
===============================
CONFUSION MATRIX:
[[350 0]
[ 0 187]]
ACCURACY SCORE:
1.0000
CLASSIFICATION REPORT:
0 1 accuracy macro avg weighted avg
precision 1.0 1.0 1.0 1.0 1.0
recall 1.0 1.0 1.0 1.0 1.0
f1-score 1.0 1.0 1.0 1.0 1.0
support 350.0 187.0 1.0 537.0 537.0
TESTING RESULTS:
===============================
CONFUSION MATRIX:
[[127 23]
[ 38 43]]
ACCURACY SCORE:
0.7359
CLASSIFICATION REPORT:
0 1 accuracy macro avg weighted avg
precision 0.769697 0.651515 0.735931 0.710606 0.728257
recall 0.846667 0.530864 0.735931 0.688765 0.735931
f1-score 0.806349 0.585034 0.735931 0.695692 0.728745
support 150.000000 81.000000 0.735931 231.000000 231.000000
1.3 Дополнительные деревья - ET
Extra Trees (ET) - это модификация мешков. ExtraTreesClassifier () - это класс из библиотеки sklearn, который создает мета-оценку для соответствия нескольким рандомизированным деревьям решений (также известным как ET) различных подвыборок. Затем ET вычисляет средний прогноз среди подвыборок. Это позволяет повысить точность модели и контролировать переоснащение.
from sklearn.ensemble import ExtraTreesClassifier
ex_tree_clf = ExtraTreesClassifier(n_estimators=1000, max_features=7, random_state=42)
ex_tree_clf.fit(X_train, y_train)
evaluate(ex_tree_clf, X_train, X_test, y_train, y_test)
TRAINIG RESULTS:
===============================
CONFUSION MATRIX:
[[350 0]
[ 0 187]]
ACCURACY SCORE:
1.0000
CLASSIFICATION REPORT:
0 1 accuracy macro avg weighted avg
precision 1.0 1.0 1.0 1.0 1.0
recall 1.0 1.0 1.0 1.0 1.0
f1-score 1.0 1.0 1.0 1.0 1.0
support 350.0 187.0 1.0 537.0 537.0
TESTING RESULTS:
===============================
CONFUSION MATRIX:
[[124 26]
[ 32 49]]
ACCURACY SCORE:
0.7489
CLASSIFICATION REPORT:
0 1 accuracy macro avg weighted avg
precision 0.794872 0.653333 0.748918 0.724103 0.745241
recall 0.826667 0.604938 0.748918 0.715802 0.748918
f1-score 0.810458 0.628205 0.748918 0.719331 0.746551
support 150.000000 81.000000 0.748918 231.000000 231.000000
2. Повышение
Повышение - это еще один метод построения нескольких моделей (также из одного и того же типа); однако каждая модель учится исправлять ошибки прогнозирования предыдущей модели во всей последовательности моделей. Повышение в первую очередь используется для уравновешивания смещения и дисперсии в моделях контролируемого машинного обучения. Boosting - это алгоритм, который превращает слабых учеников в сильных.
Повышение позволяет построить базовый оценщик последовательно из слабых, а затем уменьшить смещение комбинированных оценщиков.
2.1 AdaBoost (AD)
AdaBoost (AD) взвешивает экземпляры набора данных, классифицируя функции. Это позволяет алгоритму учитывать эти особенности при построении последующей модели.
from sklearn.ensemble import AdaBoostClassifier
ada_boost_clf = AdaBoostClassifier(n_estimators=30)
ada_boost_clf.fit(X_train, y_train)
evaluate(ada_boost_clf, X_train, X_test, y_train, y_test)
TRAINIG RESULTS:
===============================
CONFUSION MATRIX:
[[314 36]
[ 49 138]]
ACCURACY SCORE:
0.8417
CLASSIFICATION REPORT:
0 1 accuracy macro avg weighted avg
precision 0.865014 0.793103 0.841713 0.829059 0.839972
recall 0.897143 0.737968 0.841713 0.817555 0.841713
f1-score 0.880785 0.764543 0.841713 0.822664 0.840306
support 350.000000 187.000000 0.841713 537.000000 537.000000
TESTING RESULTS:
===============================
CONFUSION MATRIX:
[[129 21]
[ 36 45]]
ACCURACY SCORE:
0.7532
CLASSIFICATION REPORT:
0 1 accuracy macro avg weighted avg
precision 0.781818 0.681818 0.753247 0.731818 0.746753
recall 0.860000 0.555556 0.753247 0.707778 0.753247
f1-score 0.819048 0.612245 0.753247 0.715646 0.746532
support 150.000000 81.000000 0.753247 231.000000 231.000000
2.2 Стохастическое повышение градиента (SGB)
Стохастическое градиентное усиление (SGB) - один из передовых алгоритмов ансамбля. На каждой итерации SGB случайным образом отбирает подвыборку из обучающего набора (без замены). Затем подвыборка используется для соответствия базовой модели (учащийся) до тех пор, пока ошибка не станет стабильной.
from sklearn.ensemble import GradientBoostingClassifier
grad_boost_clf = GradientBoostingClassifier(n_estimators=100, random_state=42)
grad_boost_clf.fit(X_train, y_train)
evaluate(grad_boost_clf, X_train, X_test, y_train, y_test)
TRAINIG RESULTS:
===============================
CONFUSION MATRIX:
[[339 11]
[ 26 161]]
ACCURACY SCORE:
0.9311
CLASSIFICATION REPORT:
0 1 accuracy macro avg weighted avg
precision 0.928767 0.936047 0.931099 0.932407 0.931302
recall 0.968571 0.860963 0.931099 0.914767 0.931099
f1-score 0.948252 0.896936 0.931099 0.922594 0.930382
support 350.000000 187.000000 0.931099 537.000000 537.000000
TESTING RESULTS:
===============================
CONFUSION MATRIX:
[[126 24]
[ 37 44]]
ACCURACY SCORE:
0.7359
CLASSIFICATION REPORT:
0 1 accuracy macro avg weighted avg
precision 0.773006 0.647059 0.735931 0.710032 0.728843
recall 0.840000 0.543210 0.735931 0.691605 0.735931
f1-score 0.805112 0.590604 0.735931 0.697858 0.729895
support 150.000000 81.000000 0.735931 231.000000 231.000000
3. Голосование
Голосование - это набор одинаково эффективных моделей, позволяющих уравновесить их слабые стороны. Голосование использует три подхода к процедуре голосования: жесткий, мягкий и взвешенный.
- Жесткое голосование - предсказывает большинство ярлыков класса.
- Мягкое голосование - argmax суммы прогнозируемых вероятностей.
- Взвешенное голосование - argmax взвешенной суммы прогнозируемых вероятностей.
Голосование просто и легко реализуемо. Во-первых, он создает две автономные модели (в зависимости от варианта использования может быть больше) из набора данных. Затем используется классификатор голосования для обертывания моделей и усреднения прогнозов подмоделей при введении новых данных.
from sklearn.ensemble import VotingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
estimators = []
log_reg = LogisticRegression(solver='liblinear')
estimators.append(('Logistic', log_reg))
tree = DecisionTreeClassifier()
estimators.append(('Tree', tree))
svm_clf = SVC(gamma='scale')
estimators.append(('SVM', svm_clf))
voting = VotingClassifier(estimators=estimators)
voting.fit(X_train, y_train)
evaluate(voting, X_train, X_test, y_train, y_test)
TRAINIG RESULTS:
===============================
CONFUSION MATRIX:
[[328 22]
[ 75 112]]
ACCURACY SCORE:
0.8194
CLASSIFICATION REPORT:
0 1 accuracy macro avg weighted avg
precision 0.813896 0.835821 0.819367 0.824858 0.821531
recall 0.937143 0.598930 0.819367 0.768037 0.819367
f1-score 0.871182 0.697819 0.819367 0.784501 0.810812
support 350.000000 187.000000 0.819367 537.000000 537.000000
TESTING RESULTS:
===============================
CONFUSION MATRIX:
[[135 15]
[ 40 41]]
ACCURACY SCORE:
0.7619
CLASSIFICATION REPORT:
0 1 accuracy macro avg weighted avg
precision 0.771429 0.732143 0.761905 0.751786 0.757653
recall 0.900000 0.506173 0.761905 0.703086 0.761905
f1-score 0.830769 0.598540 0.761905 0.714655 0.749338
support 150.000000 81.000000 0.761905 231.000000 231.000000
4. Укладка
Укладка работает по тому же принципу, что и ансамбль для голосования. Однако стекинг может контролировать возможность настройки прогнозов подмоделей последовательно - в качестве входных данных для метамодели для повышения производительности. Другими словами, суммирование генерирует прогнозы на основе алгоритма каждой модели; впоследствии метамодель использует эти прогнозы в качестве входных данных (весов) для создания окончательных выходных данных.
Преимущество стекирования заключается в том, что он может объединять разных сильных учеников и делать точные и надежные прогнозы, чем любая отдельная модель.
В библиотеке sklearn есть StackingClassifier () под модулем ансамбля, вы можете найти ссылку здесь. Однако я буду реализовывать ансамбль стекирования с помощью библиотеки ML-Ensemble.
Чтобы провести честное сравнение между наложением и предыдущими ансамблями, я пересчитал предыдущую точность, используя кратность 10.
from mlens.ensemble import SuperLearner
# create a list of base-models
def get_models():
models = list()
models.append(LogisticRegression(solver='liblinear'))
models.append(DecisionTreeClassifier())
models.append(SVC(gamma='scale', probability=True))
models.append(GaussianNB())
models.append(KNeighborsClassifier())
models.append(AdaBoostClassifier())
models.append(BaggingClassifier(n_estimators=10))
models.append(RandomForestClassifier(n_estimators=10))
models.append(ExtraTreesClassifier(n_estimators=10))
return models
def get_super_learner(X):
ensemble = SuperLearner(scorer=accuracy_score,
folds = 10,
random_state=41)
model = get_models()
ensemble.add(model)
# add some layers to the ensemble structure
ensemble.add([LogisticRegression(), RandomForestClassifier()])
ensemble.add([LogisticRegression(), SVC()])
# add meta model
ensemble.add_meta(SVC())
return ensemble
# create the super learner
ensemble = get_super_learner(X_train)
# fit the super learner
ensemble.fit(X_train, y_train)
# summarize base learners
print(ensemble.data)
# make predictions on hold out set
yhat = ensemble.predict(X_test)
print('Super Learner: %.3f' % (accuracy_score(y_test, yhat) * 100))
ACCURACY SCORE ON TRAIN: 83.24022346368714 ACCURACY SCORE ON TEST: 76.62337662337663
Сравните производительность
import plotly.graph_objects as go
fig = go.Figure()
fig.add_trace(go.Bar(
x = test['Algo'],
y = test['Train'],
text = test['Train'],
textposition='auto',
name = 'Accuracy on Train set',
marker_color = 'indianred'))
fig.add_trace(go.Bar(
x = test['Algo'],
y = test['Test'],
text = test['Test'],
textposition='auto',
name = 'Accuracy on Test set',
marker_color = 'lightsalmon'))
fig.update_traces(texttemplate='%{text:.2f}')
fig.update_layout(title_text='Comprehensive comparasion between ensembles on Train and Test set')
fig.show()
Как показано, составной ансамбль отлично показал себя на тестовой выборке, при этом наивысшая точность классификации составляет 76,623%. Большой!
4. Выводы и выводы
Мы изучили несколько типов ансамблей и научились правильно их применять, чтобы расширить предсказательную силу модели. Мы также пришли к выводу о некоторых важных моментах, которые следует учитывать:
- Стекинг показал повышение точности, надежности и лучшего обобщения.
- Мы можем использовать голосование в тех случаях, когда мы хотим установить одинаково эффективные модели, чтобы уравновесить их слабые стороны.
- Бустинг - отличный ансамбль; Он просто объединяет несколько слабых учеников, чтобы получить более сильного.
- Вы можете рассмотреть возможность использования бэггинга, если хотите создать модель с меньшими отклонениями, комбинируя разные хорошие модели - уменьшите переоснащение.
- Выбор подходящего ансамбля зависит от бизнес-задачи и желаемого результата.
Наконец, я хотел бы, чтобы это дало исчерпывающее руководство по реализации ансамблей и получению от них максимальной отдачи. Если вы столкнулись с какими-либо проблемами, перечислите их в разделе комментариев; Буду рад помочь. Лучший способ воодушевить меня - это подписаться на меня в Medium, LinkedIn, или Github. Удачного обучения!
