Ансамбълните методи са техники, които създават множество модели и след това ги комбинират, за да се получат подобрени резултати. Ансамбълните методи обикновено дават по-точни решения, отколкото би направил един модел. Такъв е случаят в редица състезания по машинно обучение, където печелившите решения използваха ансамблови методи. В популярното състезание Netflix, победителят използва ансамблов метод за внедряване на мощен алгоритъм за съвместно филтриране. Друг пример е KDD 2009, където победителят също използвани ансамблови методи . Можете също така да намерите победители, които са използвали тези методи например в състезания Kaggle тук е интервюто с победителя в Състезание CrowdFlower .

Важно е да разберем няколко терминологии, преди да продължим с тази статия. В статията използвах термина „модел“, за да опиша изхода на алгоритъма, обучен с данни. След това този модел се използва за изготвяне на прогнози. Този алгоритъм може да бъде всеки машинно обучение алгоритъм като логистична регресия, дърво за вземане на решения и др. Тези модели, когато се използват като входове на ансамбълните методи, се наричат ​​„базови модели“.

В този пост в блога ще разгледам ансамбълните методи за класификация и ще опиша някои широко известни методи за ансамбъл: гласуване, подреждане, пакетиране и усилване.

Методи на ансамбъл въз основа на гласуване и осредняване

Гласуването и усредняването са два от най-лесните методи на ансамбъла. И двамата са лесни за разбиране и изпълнение. Гласуването се използва за класификация, а усредняването - за регресия.

И при двата метода първата стъпка е да се създадат множество модели за класификация / регресия, като се използва някакъв набор от данни за обучение. Всеки основен модел може да бъде създаден, като се използват различни разделения на един и същ набор от данни за обучение и един и същ алгоритъм, или като се използва един и същ набор от данни с различни алгоритми или друг метод. Следващият псевдокод на Python-esque показва използването на един и същ набор от данни за обучение с различни алгоритми.

как да използвате junit тестване

train = load_csv('train.csv') target = train['target'] train = train.drop('target') test = load_csv('test.csv') algorithms = [logistic_regression, decision_tree_classification, ...] #for classification algorithms = [linear_regression, decision_tree_regressor, ...] #for regression predictions = matrix(row_length=len(target), column_length=len(algorithms)) for i,algorithm in enumerate(algorithms): predictions[,i] = algorithm.fit(train, target).predict(test)

Съгласно горния псевдокод, ние създадохме прогнози за всеки модел и ги запазихме в матрица, наречена прогнози, където всяка колона съдържа прогнози от един модел.

Гласуване на мнозинството

Всеки модел прави прогноза (гласове) за всеки тестов екземпляр и крайната изходна прогноза е тази, която получава повече от половината от гласовете. Ако никоя от прогнозите не получи повече от половината гласове, можем да кажем, че методът на ансамбъла не може да направи стабилна прогноза за този случай. Въпреки че това е широко използвана техника, можете да опитате най-гласуваната прогноза (дори ако това е по-малко от половината от гласовете) като окончателна прогноза. В някои статии може да видите този метод да се нарича „множествено гласуване“.

назовете инструмента за проектиране, който може да се използва за установяване на пространствена йерархия на съдържанието

Претеглено гласуване

За разлика от гласуването с мнозинство, където всеки модел има едни и същи права, ние можем да увеличим значението на един или повече модели. При претеглено гласуване броите прогнозите за по-добрите модели няколко пъти. Намирането на разумен набор от тежести зависи от вас.

Просто усредняване

В прост метод на осредняване за всеки екземпляр от тестов набор от данни се изчисляват средните прогнози. Този метод често намалява свръхголемината и създава по-плавен модел на регресия. Следният псевдокод показва този прост метод за усредняване:

final_predictions = [] for row_number in len(predictions): final_predictions.append( mean(prediction[row_number, ]) )

Претеглено осредняване

Претегленото осредняване е леко модифицирана версия на просто усредняване, където прогнозата за всеки модел се умножава по тежестта и след това се изчислява тяхната средна стойност. Следният псевдокод показва претегленото осредняване:

weights = [..., ..., ...] #length is equal to len(algorithms) final_predictions = [] for row_number in len(predictions): final_predictions.append( mean(prediction[row_number, ]*weights) )

Подреждане на множество модели за машинно обучение

Подреждането, известно още като обобщено подреждане, е ансамблов метод, при който моделите се комбинират, използвайки друг машинно обучение алгоритъм. Основната идея е да се обучат алгоритми за машинно обучение с набор от данни за обучение и след това да се генерира нов набор от данни с тези модели. След това този нов набор от данни се използва като вход за алгоритъма за машинно обучение на комбинатора.

Псевдокодът на процедурата за подреждане е обобщен както по-долу:

base_algorithms = [logistic_regression, decision_tree_classification, ...] #for classification stacking_train_dataset = matrix(row_length=len(target), column_length=len(algorithms)) stacking_test_dataset = matrix(row_length=len(test), column_length=len(algorithms)) for i,base_algorithm in enumerate(base_algorithms): stacking_train_dataset[,i] = base_algorithm.fit(train, target).predict(train) stacking_test_dataset[,i] = base_algorithm.predict(test) final_predictions = combiner_algorithm.fit(stacking_train_dataset, target).predict(stacking_test_dataset)

Както можете да видите в горния псевдокод, учебният набор от данни за комбиниращ алгоритъм се генерира, като се използват изходите на базовите алгоритми. В псевдокода базовият алгоритъм се генерира с помощта на набор от данни за обучение и след това същият набор от данни се използва отново, за да прави прогнози. Но както знаем, в реалния свят не използваме един и същ набор от данни за обучение за прогнозиране, така че за преодоляване на този проблем може да видите някои изпълнения на подреждане, където данните за обучение са разделени. По-долу можете да видите псевдокод, където наборът от данни за обучение е разделен преди обучението на базовите алгоритми:

какво прави финансовият директор на една компания

base_algorithms = [logistic_regression, decision_tree_classification, ...] #for classification stacking_train_dataset = matrix(row_length=len(target), column_length=len(algorithms)) stacking_test_dataset = matrix(row_length=len(test), column_length=len(algorithms)) for i,base_algorithm in enumerate(base_algorithms): for trainix, testix in split(train, k=10): #you may use sklearn.cross_validation.KFold of sklearn library stacking_train_dataset[testcv,i] = base_algorithm.fit(train[trainix], target[trainix]).predict(train[testix]) stacking_test_dataset[,i] = base_algorithm.fit(train).predict(test) final_predictions = combiner_algorithm.fit(stacking_train_dataset, target).predict(stacking_test_dataset)

Bootstrap Агрегиране

Името Bootstrap Aggregating, известно още като „Bagging“, обобщава ключовите елементи на тази стратегия. В алгоритъма за пакетиране първата стъпка включва създаването на множество модели. Тези модели се генерират, използвайки същия алгоритъм с произволни подпроби от набора от данни, които са извлечени от оригиналния набор от данни на случаен принцип с метод за вземане на проби от bootstrap. В извадката на bootstrap някои оригинални примери се появяват повече от веднъж, а някои оригинални примери не присъстват в извадката. Ако искате да създадете под-набор от данни с m елемента, трябва да изберете произволен елемент от оригиналния набор от данни m пъти. И ако целта е генериране на n набор от данни, следвате тази стъпка n пъти.

В края имаме n набора от данни, където броят на елементите във всеки набор от данни е m. Следният псевдокод на Python-esque показва вземане на проби от bootstrap:

def bootstrap_sample(original_dataset, m): sub_dataset = [] for i in range(m): sub_dataset.append( random_one_element(original_dataset) ) return sub_dataset

Втората стъпка в пакетирането е обобщаването на генерираните модели. За тази цел се използват добре познати методи, като гласуване и усредняване.

Цялостният псевдокод изглежда така:

def bagging(n, m, base_algorithm, train_dataset, target, test_dataset): predictions = matrix(row_length=len(target), column_length=n) for i in range(n): sub_dataset = bootstrap_sample(train_dataset, m) predictions[,i] = base_algorithm.fit(original_dataset, target).predict(test_dataset) final_predictions = voting(predictions) # for classification final_predictions = averaging(predictions) # for regression return final_predictions

При пакетирането всяка подпроба може да бъде генерирана независимо една от друга. Така че генерирането и обучението могат да се извършват паралелно.

какво е бот в дискорд

Можете също така да намерите изпълнение на стратегията за пакетиране в някои алгоритми. Например, Случайна гора алгоритъмът използва техниката на пакетиране с някои разлики. Random Forest използва произволен избор на характеристики, а основният алгоритъм за нея е алгоритъм на дървото за вземане на решения.

Свързани: Урок за дълбоко обучение: От перцептрони до дълбоки мрежи

Повишаване: Преобразуване на слаби модели в силни

Терминът „усилване“ се използва за описване на семейство алгоритми, които могат да конвертират слаби модели в силни модели. Моделът е слаб, ако има значителен процент грешки, но производителността не е случайна (в резултат на степента на грешки е 0,5 за двоична класификация). Постепенното усилване изгражда ансамбъл чрез обучение на всеки модел със същия набор от данни, но където теглата на екземплярите се коригират според грешката на последното предвиждане. Основната идея е да принудите моделите да се съсредоточат върху случаите, които са трудни. За разлика от багажа, усилването е последователен метод и затова не можете да използвате паралелни операции тук.

Общата процедура на ускоряващия алгоритъм се определя, както следва:

def adjust_dataset(_train, errors): #create a new dataset by using the hardest instances ix = get_highest_errors_index(train) return concat(_train[ix], random_select(train)) models = [] _train = random_select(train) for i in range(n): #n rounds model = base_algorithm.fit(_train) predictions = model.predict(_train) models.append(model) errors = calculate_error(predictions) _train = adjust_dataset(_train, errors) final_predictions = combine(models, test)

Функцията Adjust_dataset връща нов набор от данни, съдържащ най-трудните екземпляри, които след това могат да бъдат използвани, за да принудят базовия алгоритъм да се учи.

Adaboost е широко известен алгоритъм, който е усилващ метод. Основателите на Adaboost спечелиха Награда в Гьодел за тяхната работа. Най-вече алгоритъмът на дървото за решения се предпочита като основен алгоритъм за Adaboost, а в библиотеката sklearn основният алгоритъм по подразбиране за Adaboost е дървото за решения ( AdaBoostRegressor и AdaBoostClassifier ). Както обсъждахме в предишния параграф, същият инкрементален метод се прилага за Adaboost. В модела се подава информация, събрана на всяка стъпка от алгоритъма на AdaBoost за „твърдостта“ на всяка тренировъчна проба. Стъпката „коригиране на набор от данни“ се различава от описаната по-горе и стъпката „комбиниране на модели“ се изчислява чрез използване на претеглено гласуване.

Заключение

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

Свързани:

• Въведение в теорията на машинното обучение и нейните приложения: Визуален урок с примери
• Машини и доверие: Как да смекчим пристрастията на AI