Ансамблевое обучение: эффективный способ повысить производительность вашей модели машинного обучения!
В моем предыдущем блоге я объяснил предвзятость, дисперсию и неустранимые ошибки.
Вот ссылка на блог -› Неустранимая ошибка дисперсии смещения и компромисс сложности модели
Одним из методов уменьшения этих ошибок (предвзятости и дисперсии) является ансамблевое обучение. Он объединяет несколько моделей машинного обучения для получения оптимизированных результатов с уменьшенной дисперсией (упаковка), смещением (повышение) и улучшенным прогнозированием (накопление).
В этом блоге вы попрактикуетесь в методах ансамблевого обучения.
Источник данных:
Мы собираемся использовать базу данных Pima-Indians-diabetes по ссылке ниже. Загрузите файл мочеизнурения.csv по ссылке ниже.
База данных о диабете индейцев пима
Загрузите открытые наборы данных по тысячам проектов + поделитесь проектами на одной платформе. Исследуйте популярные темы, такие как правительство…www.kaggle.comT
Наборы данных состоят из нескольких медицинских предикторов (независимых) и одной целевой (зависимой) переменной Результат. К независимым переменным относятся количество беременностей, которые были у пациентки, ее ИМТ, уровень инсулина, возраст и т. д.
Вызов:
Прогнозируйте исход (диабет или нет) на основе ИМТ пациента, уровня инсулина, возраста и других значений характеристик.
Давайте попробуем разные методы обучения с учителем и посчитаем их точность.
Выполните приведенные ниже строки кода, чтобы считать данные во фрейм данных Pandas, получить матрицу значений функций, массив меток и разделить набор данных поезда и теста.
#Import Libraries import pandas as pd import numpy as np # Read data into pandas dataframe df=pd.read_csv(r'<put your file path here>\diabetes.csv') #Define Feature Matrix (X) and Label Array (y) X=df.drop(['Outcome'],axis=1) y=df['Outcome'] #Define train and test data set from sklearn.model_selection import train_test_split X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.2,random_state=0)
Давайте попробуем разные классификаторы и посчитаем их точность.
Классификатор KNN:
from sklearn.neighbors import KNeighborsClassifier
knn=KNeighborsClassifier(n_neighbors=12)
knn.fit(X_train,y_train)
y_pred_knn=knn.predict(X_test)
print("KNN Accuracy ",knn.score(X_test,y_test))
КНН Точность 78%
KNN Accuracy 0.7857142857142857
Классификатор дерева решений:
from sklearn.tree import DecisionTreeClassifier
dec_cls=DecisionTreeClassifier()
dec_cls.fit(X_train,y_train)
y_pred_dec=dec_cls.predict(X_test)
print("Decision Tree Accuracy ",dec_cls.score(X_test,y_test))
Точность классификатора дерева решений составляет около 78%.
Decision Tree Accuracy 0.7792207792207793
Логистическая регрессия:
from sklearn.linear_model import LogisticRegression
lrc=LogisticRegression()
lrc.fit(X_train,y_train)
y_pred_log=lrc.predict(X_test)
print("Logistic Regression Accuracy ",lrc.score(X_test,y_test))
Точность логистической регрессии составляет 81%.
Logistic Regression Accuracy 0.8181818181818182
Классификатор метода опорных векторов (SVM):
from sklearn.svm import SVC
svc_classifier=SVC(kernel="linear",random_state=0)
svc_classifier.fit(X_train,y_train)
y_pred_svc=svc_classifier.predict(X_test)
print("SVC Accuracy ",svc_classifier.score(X_test,y_test))
Точность SVC составляет около 81%
SVC Accuracy 0.8181818181818182
Классификатор голосования:
Мы обучили разные модели (SVM, KNN, логистика, дерево решений), используя один и тот же набор обучающих данных, и рассчитали индивидуальную точность. Как насчет того, чтобы сравнить эти модели друг с другом и выбрать лучшую из них. Это можно сделать с помощью класса VotingClassifier из sklearn.
from sklearn.ensemble import VotingClassifier
vote_cls = VotingClassifier(estimators=[('lr', svc_classifier), ('dt', lrc),('ab',knn),('dec',dec_cls)], voting='hard')
vote_cls.fit(X_train,y_train)
y_pred_vote_cls=vote_cls.predict(X_test)
print('Voting Classifier Accuracy ', vote_cls.score(X_test,y_test))
Точность классификатора голосования составляет 81%
Voting Classifier Accuracy 0.8181818181818182
Запишите опцию голосования = «жесткий» в VotingClassifier.
Существует два вида голосования: жесткое и мягкое.
а) При жестком голосовании исход определяется большинством голосов. Это похоже на выбор режима отдельных значений. У нас была следующая индивидуальная оценка точности моделей
KNN Accuracy 0.7857142857142857 Decision Tree Accuracy 0.7922077922077922 SVC Accuracy 0.8181818181818182 Logistic Regression Accuracy 0.8181818181818182
Большинство баллов составляет 81%. Неудивительно, что классификатор жесткого голосования дал точность 81%.
Однако обратите внимание, что классификатор жесткого голосования получает режим каждой предикативной метки, а не общий результат.
б) Мягкое голосование применимо в регрессионном анализе или вероятностных классификаторах (например, в логистической регрессии). Классификатор мягкого голосования вычисляет средневзвешенное значение отдельных результатов.
Бэгинг
До сих пор мы использовали разные модели на одном и том же наборе обучающих данных, получали индивидуальный прогноз и использовали классификаторы голосования, чтобы получить наилучший результат.
Вместо того, чтобы использовать разные модели в одном и том же наборе данных для обучения, как насчет разделения набора данных для обучения на несколько небольших подмножеств, обучения модели на этих данных и расчета общего результата с использованием голосования за классификатор и усреднения для регрессии. Это называется Бэггинг.
Используя начальную выборку, бэггинг создает несколько подмножеств исходных обучающих данных. Разделение обучающих данных на меньшее подмножество выполняется таким образом, чтобы каждое подмножество имело не менее 62% уникальных обучающих точек.
Примечание. Только общий набор обучающих данных разбивается на более мелкие наборы. Характеристики не нарушены. Все функции учитываются в каждом подмножестве.
Рисунок 1 поясняет бэггинг.
Так как классификатор дерева решений дал максимальную точность, давайте воспользуемся бэггингом на этой модели.
Мы собираемся разделить обучающие данные на 25 подмножеств (base_estimators).
from sklearn.ensemble import BaggingClassifier
#Bagging Decision Tree Classifier
#initialize base classifier
dec_tree_cls=DecisionTreeClassifier()
#number of base classifier
no_of_trees=25
#bagging classifier
bag_cls=BaggingClassifier(base_estimator=dec_tree_cls,n_estimators=no_of_trees,random_state=10, bootstrap=True, oob_score=True)
bag_cls.fit(X_train,y_train)
bag_cls.predict(X_test)
print("Bagging Classifier Accuracy ",bag_cls.score(X_test,y_test))
Точность увеличилась до 82%.
Bagging Classifier Accuracy 0.8246753246753247
Как видно из этого примера, бэггинг повысил точность.
Давайте попробуем упаковать с помощью классификатора KNN.
#Bagging KNN Classifier
#initialize base classifier
knn_cls=KNeighborsClassifier(n_neighbors=12)
#number of base classifier
no_of_trees=25
#bagging classifier
bag_cls=BaggingClassifier(base_estimator=knn_cls,n_estimators=no_of_trees,random_state=10, bootstrap=True, oob_score=True)
bag_cls.fit(X_train,y_train)
bag_cls.predict(X_test)
print("Bagging Classifier Accuracy ",bag_cls.score(X_test,y_test))
Точность составляет 78%.
Bagging Classifier Accuracy 0.7857142857142857
В случае KNN точность остается прежней. Бэггинг не улучшил прогноз.
Пакетирование вносит хорошие улучшения в классификаторы, такие как простое дерево решений, однако оно не может улучшить KNN. Это связано с тем, что KNN является стабильной моделью, основанной на соседних точках данных.
Случайный лес:
Случайный лес — это расширенная версия Бэгинга. В случае группового обучения данные разбиваются на несколько подмножеств без ущерба для функций. Каждое подмножество содержит все функции.
Рассмотрим типичный классификатор дерева решений. Если набор обучающих данных содержит 11 признаков, обычное дерево решений, а также классификатор Бэгинга будут содержать все 11 признаков.
В случайном лесу вместо использования всех признаков в каждом подмножестве обучающих данных выбирается случайное подмножество признаков.
Случайное дерево будет выглядеть так, как показано на рисунке ниже.
Существует более одного дерева (называемого оценщиками), и каждое дерево содержит только выбранное количество признаков.
Случайный лес — это быстрый и очень эффективный классификатор. Давайте используем это для того же набора данных и подтвердим, есть ли какие-либо улучшения.
from sklearn.ensemble import RandomForestClassifier
rnd_clf=RandomForestClassifier(n_estimators=53, n_jobs=-1, random_state=8)
rnd_clf.fit(X_train,y_train)
rnd_clf.predict(X_test)
print("Random Forest Score ",rnd_clf.score(X_test,y_test))
Оценка точности составляет 83%
Random Forest Score 0.8311688311688312
Значит, есть улучшения. Однако ключевым моментом является нахождение количества оценщиков. Распространено мнение, что чем больше оценщиков, тем веселее, но это не всегда так.
Повышение
В случае бэггинга подмножество обучающих данных передавалось в модели параллельно. Результат был определен на основе общей производительности моделей в наборе обучающих данных.
Повышение заботится о повышении производительности слабых учеников за счет уменьшения смещения и заставляет слабых учеников учиться на каждом результате предыдущей модели, запущенной на подмножестве обучающих данных. Повышение следует за последовательным обучением.
На приведенной ниже диаграмме объясняется повышение.
Адабуст
Adaboost — известный классификатор ансамблевого повышения. Он работает последовательно, как показано на рисунке выше. Он начинается со случайного подмножества обучающих данных. Он итеративно обучает модель, выбирая следующее обучающее подмножество на основе точности прогнозирования предыдущей классификации. Это уменьшает систематическую ошибку, присваивая больший вес неправильно классифицированным наблюдениям. Таким образом, на следующей итерации эти наблюдения получают более высокую вероятность классификации. Эта итерация продолжается до тех пор, пока не будет достигнуто указанное максимальное количество оценок.
Давайте воспользуемся Adaboost и подтвердим, повышает ли он точность.
from sklearn.ensemble import AdaBoostClassifier
adb_cls=AdaBoostClassifier(n_estimators=153, learning_rate=1)
adb_cls.fit(X_train,y_train)
y_adb_pred=adb_cls.predict(X_test)
print("AdaBoost Classifier ",adb_cls.score(X_test,y_test))
Исход
AdaBoost Classifier 0.8376623376623377
Неплохо! Это улучшило производительность до 83%.
Модель повышения градиента (GBM)
Модель повышения градиента является одной из наиболее часто используемых и наиболее эффективных моделей ансамбля.
Gradient Boosting можно расширить как Gradient Descent + Boosting.
Градиентный спуск фокусируется на оптимизации функции потерь. Это можно хорошо объяснить с помощью линейной регрессии.
Ниже приведено уравнение линейной регрессии.
Ниже приведена формула для функции потерь Среднеквадратичная ошибка (MSE).
Градиентный спуск фокусируется на поиске оптимальных значений веса w, таких, что MSE минимальна.
Он начинается со случайного значения w и вычисляет влияние изменения w на MSE. Он продолжает изменять w, пока не найдет минимальное значение MSE, как показано на рисунке ниже.
Размер каждого шага называется Скоростью обучения. Скорость обучения можно передать в качестве гиперпараметра классификатору. Высокая скорость обучения означает быстрое движение к оптимальной точке, однако может также привести к превышению самой низкой точки и, таким образом, к отсутствию оптимального значения w. Сохранение более низкой скорости обучения снижает этот риск, но требует большей мощности ЦП, поскольку требуется больше вычислений.
Gradient Boosting фокусируется на оптимизации остаточной ошибки. Это следует за повышающим механизмом последовательного обучения моделей. Основное внимание уделяется оптимизации функции потерь.
Запустите приведенную ниже строку кода, чтобы увидеть, есть ли какие-либо улучшения с использованием Gradient Boosting.
Здесь мы передаем разные значения скорости обучения и находим оптимальное значение скорости обучения на основе оценки модели.
from sklearn.ensemble import GradientBoostingClassifier
lr_list = [0.05, 0.075, 0.1, 0.25, 0.5, 0.75, 1,1.25,1.55,1.65,1.75]
for learning_rate in lr_list:
gb_clf = GradientBoostingClassifier(n_estimators=53, learning_rate=learning_rate, max_features=2, max_depth=2, random_state=0)
gb_clf.fit(X_train, y_train)
print("Learning rate: ", learning_rate)
print("Accuracy score (training): {0:.3f}".format(gb_clf.score(X_train, y_train)))
Результат:
Learning rate: 0.05 Accuracy score (training): 0.798 Learning rate: 0.075 Accuracy score (training): 0.805 Learning rate: 0.1 Accuracy score (training): 0.816 Learning rate: 0.25 Accuracy score (training): 0.853 Learning rate: 0.5 Accuracy score (training): 0.902 Learning rate: 0.75 Accuracy score (training): 0.925 Learning rate: 1 Accuracy score (training): 0.940 Learning rate: 1.25 Accuracy score (training): 0.953 Learning rate: 1.55 Accuracy score (training): 0.935 Learning rate: 1.65 Accuracy score (training): 0.938 Learning rate: 1.75 Accuracy score (training): 0.919
Точность можно повысить до 95,3%, используя скорость обучения 1,25.
Это большое улучшение по сравнению с 81% дерева решений базового учащегося.
Потрясающий!!
Счастливого машинного обучения до следующего блога!
Ссылка:
