Представяме ви DeepStack, пакет на Python за изграждане на ансамбли за задълбочено обучение

Изграждането на ансамбъл е водещата печеливша стратегия за състезания по машинно обучение и често техниката, използвана за решаване на проблеми от реалния свят. Това, което често се случва, е, че докато решавате проблем или участвате в състезание, в крайна сметка се оказвате с няколко обучени модела, всеки с някои разлики спрямо другия — и в крайна сметка избирате най-добрия си модел въз основа на най-добрия си резултат за оценка. Истината е, че вашият най-добър модел „знае по-малко“ за данните, отколкото всички останали „слаби модели“ взети заедно. Комбинирането на няколко базови модела заедно, за да се създаде по-мощен комплектен модел, след това се издига като естествен страничен продукт от този работен процес.

„Наистина няма начин да спечелите повечето състезания на Kaggle без много силен ансамбъл. Колкото и добър да е най-добрият ви индивидуален модел, той няма да съвпадне с добър ансамбъл.“ Джулиано Янсон в квора (2016)

Ансамблите варират от прости до претеглени средни стойности до сложни метамодели от 2-ро и 3-то ниво. Обратно към изграждането на моите модели на ансамбъл за моите състезания по машинно обучение, в крайна сметка създадох няколко блока код, които ми помогнаха да тествам различни стратегии за ансамбъл и да спечеля или да се представя много по-добре в такива предизвикателства. И така, задавам естествения въпрос: ами ако мога да направя изграждането на ансамбли за задълбочено обучение толкова лесно, колкото да напиша няколко реда код на Python и да споделя това с общността? Тези самостоятелни проекти се превърнаха в скриптове и развиха в пакетиран Python, който нарекох DeepStack.

Кратко въведение в ансамблите

Обучението в ансамбъл е свързано с това как най-добре да комбинирате прогнози от множество съществуващи модели (наречени базови обучаеми). Всеки член на ансамбъла има принос към крайния резултат и отделните слабости се компенсират от приноса на другите членове. Комбинираният научен модел се нарича метаобучаем. Има няколко разновидности на ансамбълното обучение. В тази статия ще се съсредоточим върху 2 метода, поддържани в момента от DeepStack. а именно:

Натрупване №1: при наслагването изходът на базовите обучаеми се приема като вход за обучение на метаобучаем, който се научава как най-добре да комбинира прогнозите на базовите обучаеми.

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

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

Основната разлика между двата метода е, че при подреждането мета-обучаемият приема всеки отделен резултат от базовите обучаеми като пример за обучение, научавайки се как най-добре да картографира решенията на базовия обучаем в подобрен изход. Метаобучаемият може да бъде всеки класически известен модел на машинно обучение. Ансамбълът от претеглени средни от друга страна е само за оптимизиране на теглата, които се използват за претегляне на всички резултати на основния обучаем и вземане на среднопретеглената стойност. Тук няма мета-обучаващ се (освен тежестите). Тук броят на теглата е равен на броя на съществуващите базови обучаеми.

Излишно е да казвам, че когато изграждате ансамбъл, имате нужда от набор от данни за обучение, който не е бил видян от базовите обучаеми, за да избегнете прекомерното оборудване. Нуждаете се също от набор от данни за задържане (валидиране), за да насочвате/тествате ефективността на вашите ансамбли.

Има няколко техники за ансамбълно обучение и аз определено бих препоръчал тази статия на Джоузеф Рока, за да навлезете по-дълбоко в понятия като усилване и уплътняване. „Ръководството за ансамбъл на Kaggle“ също е добро четиво.

Упътване за DeepStack с набор от данни CIFAR-10

Готови ли сте за кодиране с реален пример? В следващите минути ще ви покажа как лесно да изграждате ансамбли с DeepStack с помощта на набора от данни CIFAR-10. Наборът от данни CIFAR-10 се състои от 60 000 цветни изображения 32x32 в 10 класа, с 6000 изображения на клас. Ще започнем да създаваме прости CNN за класифициране на изображенията и ще създадем ансамбли с единичните CNN, като използваме 2 стратегии за ансамбъл, описани по-рано. Да започваме.

pip install deepstack==0.0.9

Сега можем да използваме интерфейса DeepStack и да създадем екземпляри на класа deepstack.base.Member, който предоставя цялата необходима логика за изграждане на базовите обучаеми на ансамблите. В тази демонстрация ще започнем да използваме класа KerasMember, който наследява от Member, но има допълнителна логика за Keras Models. Обосновката е да инициираме екземпляра с набор от данни за обучение и валидиране за метаобучаемия — и ние вече изградихме помощна функция за това!

Сега може би се питате защо инициираме всичките 4 обекта с една и съща линия и набори от данни за валидиране? Е, не е нужно. Вашите keras модели може да са били обучени с различен ImageDataGenerator и можете да подадете генераторите на данни директно като аргумент към KerasMember. Това, което е важно тук е, че етикетите на класа (y_train / y_val) са равни между членовете, така че да можем да валидираме и сравним базовите обучаеми в по-късна стъпка.

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

И voilà, трябва да видите подобен резултат като този:

model1 - Weight: 0.2495 - roc_auc_score: 0.9269
model2 - Weight: 0.4498 - roc_auc_score: 0.9422
model3 - Weight: 0.0031 - roc_auc_score: 0.9090
model4 - Weight: 0.2976 - roc_auc_score: 0.9135
DirichletEnsemble roc_auc_score: 0.9523

Ансамбълът с претеглена средна стойност се представя с ~1% по-добре от най-добрия единичен модел спрямо AUC като функция за оценка по подразбиране. Както можете да видите, моделите с по-висок резултат също получиха по-високи тегла. Какво се случи под капака? Методът fit() оптимизира теглата на основните обучаеми въз основа на ефективността на функцията за целеви резултати в набора от данни за обучение. Търсенето за оптимизиране на теглото се извършва с алчно рандомизирано търсене въз основа на разпределението на Дирихле в набор от данни за валидиране. По подразбиране функцията за резултат е sklearn.metrics.roc_auc_score, но можете да подадете всяка функция за резултат към конструкторите. Методът describe()просто отпечатва производителността на единичните модели и на ансамбъла в набора от данни за валидиране.

Какво ще кажете за подреждане?

model1 - accuracy_score: 0.6116
model2 - accuracy_score: 0.6571
model3 - accuracy_score: 0.5500
model4 - accuracy_score: 0.6062
StackEnsemble accuracy_score: 0.6989

Този пример взема RandomForestRegressor от scikit-learn като meta-learner. Задачата на регресията е да се оптимизира (предскаже) вероятността на изхода на 10-те класа въз основа на изхода на вероятността на класа на основните учащи. Но вероятностите на класификатора също ще работят напълно тук. DeepStack се фокусира върху гъвкавостта и всичко зависи от вас. Този път се фокусираме върху резултата за точност и бихме могли да спечелим 4% точност с подреждане в сравнение само с най-добрия модел.

Подреждане на 3-то ниво с scikit-learn StackingClassifier

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

Scikit-learn 0.22 въвежда StackingClassifier и StackingRegressor, което ви позволява да имате стек от scikit-learn оценители с краен класификатор или регресор . хубаво! Вече можем да използваме интерфейса за подреждане на scikit-learn за изграждане на мета-обучаващ от 3-то ниво с DeepStack:

Но защо ми трябва DeepStack, ако scikit-learn вече поддържа подреждане? DeepStack е разработен за използване в случаите, когато вече имате армия от предварително обучени модели и желаете да ги обедините (ансамбълирате) заедно, създавайки още по-мощен модел. Т.е. вие не създавате и не обучавате вашите базови обучаеми с DeepStack. DeepStack също е общ и не зависи от библиотеката, използвана за създаване на базови обучаеми (keras, pytorch, tensorflow, каквото и да е).
scikit-learn stacking API поддържа създаване (обучение) на базови обучаеми от нулата с scikit-learn модели — което не е нашият случай на използване тук.

И това е само надраскване на повърхността. За да използвате DeepStack с изхода на вашите pyTorch, tensorflow и т.н. модели и да обучите мета-обучаващи за тях, проверете класа deepstack.base.Member. Можете също така да посочите всяка персонализирана функция за точкуване на целта за ансамблите. DeepStack също ви позволява да запазвате и зареждате вашите ансамбли за по-късна оптимизация.

За примерите, дадени по-горе, взехме сравнително прост модел на CNN, обучен на няколко (25) епохи. В действителност се съобщава, че по-сложни и добре обучени модели достигат до 93,17% точност на CIFAR-10, като техните среднопретеглени ансамбли достигат 94,12%. Това намаление с 1% на процента грешки изтласка резултатите отвъд точността на човешката класификация.

Вълнувате ли се да опитате DeepStack? Тогава щастлив ансамбъл!