Иногда сложно повысить точность алгоритмов машинного обучения, в этой статье будут представлены три ансамблевых алгоритма для повышения точности алгоритмов с помощью scikit-learn. Эта статья выбрана из книги «Машинное обучение — Python на практике».
В реальной жизни коллективный разум часто используется для решения проблем. Итак, можно ли в машинном обучении объединить несколько алгоритмов машинного обучения, чтобы улучшить результаты вычислений? В этом и заключается идея ансамблевых алгоритмов. Алгоритм ансамбля является одним из эффективных методов повышения точности алгоритма.В этой статье будут представлены следующие алгоритмы:
Алгоритм мешковины.
Алгоритм повышения.
Алгоритм голосования.
scikit-learn — одна из известных библиотек для разработки и применения машинного обучения в Python, работа которой зависит от SciPy и связанных с ней библиотек. Основные функции scikit-learn в основном разделены на шесть частей: классификация, регрессия, кластеризация, уменьшение размерности данных, выбор модели и предварительная обработка данных. Следует отметить, что, поскольку scikit-learn сам по себе не поддерживает ни глубокое обучение, ни ускорение графического процессора, реализация scikit-learn нейронных сетей многослойного персептрона (MLP) не подходит для крупномасштабных задач. (поддержка scikit-learn для MLP была добавлена после версии 0.18)
scikit-learn — это проект с открытым исходным кодом, соответствующий лицензии BSD, который можно использовать для коммерческой разработки. В настоящее время он в основном поддерживается членами сообщества спонтанно. Вероятно, из-за ограничения затрат на обслуживание scikit-learn более консервативен, чем другие проекты, что в основном отражается в двух аспектах:
scikit-learn никогда не выходил за пределы области машинного обучения.
scikit-learn никогда не использует алгоритмы, которые не прошли тщательную проверку.
1 Комплексный подход
Ниже приведены три популярных подхода к ансамблевым алгоритмам.
Алгоритм пакетирования: сначала разделите обучающий набор на несколько подмножеств, а затем обучите несколько моделей в каждом подмножестве.
Алгоритм повышения: обучайте несколько моделей и формируйте последовательность, каждая модель в последовательности исправляет ошибки предыдущей модели.
Алгоритм голосования: обучайте несколько моделей и используйте выборочную статистику для повышения точности модели.
В этой статье лишь кратко представлены соответствующие алгоритмы ансамбля. Здесь используется набор данных индейцев пима, и для разделения данных используется 10-кратная перекрестная проверка, а затем модель алгоритма оценивается с помощью соответствующей матрицы оценки.
2 Алгоритм упаковки
Алгоритм бэггинга — это алгоритм, который повышает точность классификации и получает оптимальное решение путем голосования за заданную комбинацию. Например, если вы больны, вы ходите в n больниц к n врачам, и каждый врач выписывает вам рецепт. это легко понять Это также идея алгоритма бэггинга. Ниже описаны три модели мешков:
Пакетированные деревья решений.
Случайный лес.
Дополнительные деревья.
2.1 Дерево решений по упаковке
Алгоритм мешков очень эффективен, когда данные имеют большую дисперсию, наиболее распространенным примером является алгоритм мешков для деревьев решений. Далее будет реализован алгоритм дерева классификации и регрессии с помощью BaggingClassifier в scikit-learn. В этом примере создается 100 деревьев решений, и код выглядит следующим образом:
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier
# 导入数据
filename = 'pima_data.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(filename, names=names)
# 将数据分为输入数据和输出结果
array = data.values
X = array[:, 0:8]
Y = array[:, 8]
num_folds = 10
seed = 7
kfold = KFold(n_splits=num_folds, random_state=seed)
cart = DecisionTreeClassifier()
num_tree = 100
model = BaggingClassifier(base_estimator=cart, n_estimators=num_tree, random_state=seed)
result = cross_val_score(model, X, Y, cv=kfold)
print(result.mean())
По сравнению с результатами классификации и деревьев регрессии в главе 12 (0,701708817498) обнаружено, что результаты значительно улучшились. Результат выполнения следующий:
0.770745044429
2.2 Случайный лес
Как следует из названия, случайный лес предназначен для построения леса случайным образом.Лес состоит из множества деревьев решений, и между каждым деревом решений нет никакой связи. После получения леса, когда поступает новая входная выборка, пусть каждое дерево решений в лесу оценивает отдельно, чтобы увидеть, к какой категории должна принадлежать выборка, а затем посмотреть, какая категория выбрана больше всего, а затем предсказать, к какому классу принадлежит эта выборка.
В процессе построения каждого дерева решений следует обратить внимание на два момента: выборка и полное разбиение. Во-первых, это процесс двух случайных выборок, Случайный лес должен выбирать строки и столбцы входных данных. Для выборки строк принят метод с замещением, то есть в выборке, полученной путем выборки, могут быть повторяющиеся выборки. Если предположить, что входных отсчетов N, то выборочных отсчетов также N. Таким образом, во время обучения не все входные выборки каждого дерева являются выборками, и их относительно сложно перенастроить. Затем выполните выборку столбца и выберите m из M признаков (m
Каждое дерево решений в случайном лесу, полученном с помощью этого алгоритма, слабое, но вместе они могут быть мощными. Я думаю, что алгоритм случайного леса можно сравнить так: каждое дерево решений — это эксперт, который разбирается в определенной области, поэтому в случайном лесу есть много экспертов, которые разбираются в разных областях, для новой задачи (новые входные данные ), можно посмотреть на него с разных сторон, а в итоге получить результаты по голосам разных экспертов.
Класс реализации этого алгоритма в scikit-learn — RandomForestClassifier. В следующем примере реализуется случайный лес из 100 деревьев. код показывает, как показано ниже:
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import RandomForestClassifier
# 导入数据
filename = 'pima_data.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(filename, names=names)
# 将数据分为输入数据和输出结果
array = data.values
X = array[:, 0:8]
Y = array[:, 8]
num_folds = 10
seed = 7
kfold = KFold(n_splits=num_folds, random_state=seed)
num_tree = 100
max_features = 3
model = RandomForestClassifier(n_estimators=num_tree, random_state=seed, max_features=max_features)
result = cross_val_score(model, X, Y, cv=kfold)
print(result.mean())
Результат выполнения следующий:
0.77337662337
2.3 Экстремальные случайные деревья
Экстремальные случайные деревья были предложены Пьером Гертсом и др. в 2006 г. и очень похожи на случайные леса тем, что состоят из множества деревьев решений. Но у него есть два основных отличия от случайных лесов:
(1) Случайный лес использует модель Бэгинга, а экстремальное случайное дерево использует все обучающие выборки для получения каждого дерева решений, то есть каждое дерево решений применяет одни и те же все обучающие выборки.
(2) Случайный лес получает атрибут оптимального бифуркационного признака в случайном подмножестве, в то время как экстремальное случайное дерево выбирает атрибут бифуркационного признака совершенно случайно, тем самым реализуя бифуркацию дерева решений.
Его класс реализации в scikit-learn — ExtraTreesClassifier. Пример ниже представляет собой чрезвычайно случайное дерево, реализованное с 100 деревьями и 7 случайными функциями. код показывает, как показано ниже:
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import ExtraTreesClassifier
# 导入数据
filename = 'pima_data.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(filename, names=names)
# 将数据分为输入数据和输出结果
array = data.values
X = array[:, 0:8]
Y = array[:, 8]
num_folds = 10
seed = 7
kfold = KFold(n_splits=num_folds, random_state=seed)
num_tree = 100
max_features = 7
model = ExtraTreesClassifier(n_estimators=num_tree, random_state=seed, max_features=max_features)
result = cross_val_score(model, X, Y, cv=kfold)
print(result.mean())
Результат выполнения следующий:
0.762987012987
3 Алгоритмы повышения
Повышение — это метод, используемый для повышения точности слабых алгоритмов классификации путем сначала построения ряда функций прогнозирования, а затем их объединения в функцию прогнозирования определенным образом. Алгоритм повышения также является методом повышения точности любого заданного алгоритма обучения.Это алгоритм ансамбля, который в основном получает подмножество выборки, работая с набором выборок, а затем использует алгоритм слабой классификации для обучения на подмножестве выборки для создать серию базового классификатора. Его можно использовать для повышения скорости распознавания других слабых алгоритмов классификации, то есть поместить другие слабые алгоритмы классификации в качестве базовых алгоритмов классификации в структуру продвижения и получить различные подмножества обучающей выборки посредством работы структуры улучшения на наборе обучающей выборки. Используйте это подмножество образцов для обучения сгенерированного базового классификатора. Каждый раз, когда получается набор выборок, алгоритм базовой классификации используется для создания базового классификатора в наборе выборок, так что после заданного количества раундов обучения n можно сгенерировать n базовых классификаторов, а затем алгоритм повышения классифицирует n базовые классификаторы.Взвешенное слияние классификаторов дает окончательный классификатор результата. Среди n базовых классификаторов скорость распознавания каждого классификатора не обязательно высока, но результат их комбинации имеет высокую скорость распознавания, что улучшает скорость распознавания слабого алгоритма классификации. Вот два очень распространенных алгоритма повышения, используемых в машинном обучении:
АдаБуст.
Стохастическое повышение градиента.
3.1 AdaBoost
AdaBoost — это итеративный алгоритм, основная идея которого заключается в обучении различных классификаторов (слабых классификаторов) для одного и того же обучающего набора, а затем в объединении этих слабых классификаторов для формирования более сильного конечного классификатора (сильного классификатора). Сам алгоритм реализуется путем изменения распределения данных, он определяет вес каждой выборки в соответствии с правильностью классификации каждой выборки в каждой обучающей выборке и точностью последней общей классификации. Он отправляет новый набор данных с измененными весами нижнему классификатору для обучения, а затем объединяет классификаторы, полученные в результате каждого обучения, в качестве окончательного классификатора решений. Использование классификатора AdaBoost может исключить некоторые ненужные функции данных обучения и поместить их в ключевые данные обучения. Класс реализации в scikit-learn — AdaBoostClassifier. код показывает, как показано ниже:
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import AdaBoostClassifie
# 导入数据
filename = 'pima_data.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(filename, names=names)
# 将数据分为输入数据和输出结果
array = data.values
X = array[:, 0:8]
Y = array[:, 8]
num_folds = 10
seed = 7
kfold = KFold(n_splits=num_folds, random_state=seed)
num_tree = 30
model = AdaBoostClassifier(n_estimators=num_tree, random_state=seed)
result = cross_val_score(model, X, Y, cv=kfold)
print(result.mean())
Результат выполнения следующий:
0.76045796309
3.2 Стохастическое повышение градиента
Стохастическое повышение градиента (GBM) основано на идее, что лучший способ найти максимальное значение функции — это искать вдоль направления градиента функции. Оператор градиента всегда указывает в направлении самого быстрого роста значения функции. Поскольку алгоритм повышения градиента должен проходить весь набор данных каждый раз, когда набор данных обновляется, вычислительная сложность высока, поэтому существует улучшенный алгоритм — алгоритм стохастического повышения градиента, который использует только одну точку выборки за раз для обновления. коэффициент регрессии. Вычислительная сложность алгоритма значительно улучшена. Класс реализации в scikit-learn — GradientBoostingClassifier. код показывает, как показано ниже:
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import GradientBoostingClassifier
# 导入数据
filename = 'pima_data.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(filename, names=names)
# 将数据分为输入数据和输出结果
array = data.values
X = array[:, 0:8]
Y = array[:, 8]
num_folds = 10
seed = 7
kfold = KFold(n_splits=num_folds, random_state=seed)
num_tree = 100
model = GradientBoostingClassifier(n_estimators=num_tree, random_state=seed)
result = cross_val_score(model, X, Y, cv=kfold)
print(result.mean())
Результат выполнения следующий:
0.766900205058
4 Алгоритм голосования
Голосование — это очень простой ансамбль нескольких алгоритмов машинного обучения. Алгоритм голосования заключается в создании двух или более моделей алгоритмов, объединении этих алгоритмов с алгоритмом голосования и вычислении среднего состояния прогнозирования каждой подмодели. В практических приложениях к результатам прогнозирования каждой подмодели можно добавить веса, чтобы повысить точность алгоритма. Однако алгоритмы взвешивания не предусмотрены в scikit-learn. Ниже приведен пример, показывающий, как реализовать алгоритм голосования в scikit-learn. Класс реализации в scikit-learn — VotingClassifier. код показывает, как показано ниже:
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import VotingClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.linear_model import LogisticRegression
# 导入数据
filename = 'pima_data.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(filename, names=names)
# 将数据分为输入数据和输出结果
array = data.values
X = array[:, 0:8]
Y = array[:, 8]
num_folds = 10
seed = 7
kfold = KFold(n_splits=num_folds, random_state=seed)
cart = DecisionTreeClassifier()
models = []
model_logistic = LogisticRegression()
models.append(('logistic', model_logistic))
model_cart = DecisionTreeClassifier()
models.append(('cart', model_cart))
model_svc = SVC()
models.append(('svm', model_svc))
ensemble_model = VotingClassifier(estimators=models)
result = cross_val_score(ensemble_model, X, Y, cv=kfold)
print(result.mean())
Результат выполнения следующий:
0.732997265892