Джедайска техника за редуциране на конволюционни мрежи - подрязване

Пред вас отново е задачата за откриване на обекти. Приоритет е скоростта на работа с приемлива точност. Взимате архитектурата YOLOv3 и я обучавате допълнително. Точността (mAp75) е по-голяма от 0.95. Но скоростта на движение е все още ниска. глупости.

Днес ще заобиколим квантуването. И под разреза ще погледнем Модел Резитба — изрязване на излишни части от мрежата за ускоряване на извода без загуба на точност. Ясно е къде, колко и как да се реже. Нека да разберем как да направите това ръчно и къде можете да го автоматизирате. В края има хранилище на keras.

въведение

На предишното ми място на работа, Macroscop в Перм, придобих един навик - винаги да следя времето за изпълнение на алгоритмите. И винаги проверявайте времето за изпълнение на мрежата чрез филтър за адекватност. Обикновено най-модерното в производството не преминава този филтър, което ме доведе до Pruning.

Резитбата е стара тема, която беше обсъждана в Лекции в Станфорд през 2017 г. Основната идея е да се намали размерът на обучената мрежа, без да се губи точността чрез премахване на различни възли. Звучи страхотно, но рядко чувам за употребата му. Вероятно няма достатъчно реализации, няма статии на руски език или просто всички го смятат за ноу-хау за подрязване и мълчат.
Но нека го разделим

Поглед към биологията

Обичам, когато Deep Learning разглежда идеи, които идват от биологията. На тях, подобно на еволюцията, може да се вярва (знаете ли, че ReLU е много подобен на функция за активиране на неврони в мозъка?)

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

1. Мозъкът на жена, родена само с едната половина, се е препрограмирал да изпълнява функциите на липсващата половина.
2. Човекът изстреля частта от мозъка си, отговорна за зрението. С течение на времето други части на мозъка поеха тези функции. (не се опитваме да повтаряме)

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

Харесвате ли Transfer Learning или учите от нулата?

Вариант номер едно. Използвате Transfer Learning на Yolov3. Retina, Mask-RCNN или U-Net. Но през повечето време не е необходимо да разпознаваме 80 класа обекти, както в COCO. В моята практика всичко е ограничено до 1-2 клас. Може да се предположи, че архитектурата за 80 класа е излишна тук. Това предполага, че архитектурата трябва да бъде намалена. Освен това бих искал да направя това, без да губя съществуващите предварително тренирани тежести.

Вариант номер две. Може би имате много данни и изчислителни ресурси или просто се нуждаете от суперперсонализирана архитектура. няма значение Но вие изучавате мрежата от нулата. Обичайната процедура е да се разгледа структурата на данните, да се избере архитектура, която е ПРЕКАЛЕНА по мощност, и да се натиснат отпадналите от преквалификация. Видях 0.6 отпадания, Карл.

И в двата случая мрежата може да бъде намалена. Мотивиран. Сега нека да разберем какъв вид резитба е обрязването

Общ алгоритъм

Решихме, че можем да премахнем пачките. Изглежда доста просто:

Премахването на всяка конволюция е стресиращо за мрежата, което обикновено води до известно увеличение на грешката. От една страна, това увеличение на грешката е индикатор за това колко правилно премахваме навивки (например, голямо увеличение показва, че правим нещо нередно). Но малко увеличение е напълно приемливо и често се елиминира чрез последващо леко допълнително обучение с малък LR. Добавете допълнителна стъпка за обучение:

Сега трябва да разберем кога искаме да спрем цикъла Learning<->Pruning. Тук може да има екзотични опции, когато трябва да намалим мрежата до определен размер и скорост (например за мобилни устройства). Най-често срещаният вариант обаче е да продължите цикъла, докато грешката стане по-висока от допустимото. Добавете условие:

И така, алгоритъмът става ясен. Остава да разберем как да определим изтритите навивки.

Търсене на изтрити пакети

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

1. Най-малка L1-мярка или low_magnitude_pruning. Идеята, че навивките с малки тегла имат малък принос за крайното решение
2. Най-малката L1-мярка, като се вземат предвид средното и стандартното отклонение. Допълваме с оценка за характера на разпространението.
3. Маскиране на навивки и изключване на тези, които влияят най-малко на крайната точност. По-точно определяне на незначителни навивки, но много времеемки и ресурсоемки.
4. Други

Всяка от опциите има право на живот и свои собствени характеристики на изпълнение. Тук разглеждаме варианта с най-малката L1-мярка

Ръчен процес за YOLOv3

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

Затова нека изберем слоеве, от които можем свободно да изтрием съгласуванията:

Сега нека изградим работен цикъл:

1. Качване на активации
2. Разберете колко да отрежете
3. Отрязвам
4. Изучаване на 10 епохи с LR=1e-4
5. Тестване

Разтоварването на навивки е полезно, за да се оцени колко част можем да премахнем на определена стъпка. Примери за разтоварване:

Виждаме, че почти навсякъде 5% от намотките имат много ниска L1-норма и можем да ги премахнем. На всяка стъпка това разтоварване се повтаря и се преценява кои слоеве и колко могат да бъдат изрязани.

Целият процес беше завършен в 4 стъпки (цифри тук и навсякъде за RTX 2060 Super):

Стъпка	mAp75	Брой параметри, милион	Размер на мрежата, mb	От първоначално, %	Време за изпълнение, г-жо	Състояние на обрязване
0	0.9656	60	241	100	180	-
1	0.9622	55	218	91	175	5% от всички
2	0.9625	50	197	83	168	5% от всички
3	0.9633	39	155	64	155	15% за слоеве с 400+ навивки
4	0.9555	31	124	51	146	10% за слоеве с 100+ навивки

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

Автоматизация за по-прости архитектури

За по-прости мрежови архитектури (без условно добавяне, конкатернация и остатъчни блокове) е напълно възможно да се съсредоточите върху обработката на всички конволюционни слоеве и да автоматизирате процеса на изрязване на навивки.

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

import pruning
from keras.optimizers import Adam
from keras.utils import Sequence

train_batch_generator = BatchGenerator...
score_batch_generator = BatchGenerator...

opt = Adam(lr=1e-4)
pruner = pruning.Pruner("config.json", "categorical_crossentropy", opt)

pruner.prune(train_batch, valid_batch)

Ако е необходимо, можете да промените конфигурационните параметри:

{
    "input_model_path": "model.h5",
    "output_model_path": "model_pruned.h5",
    "finetuning_epochs": 10, # the number of epochs for train between pruning steps
    "stop_loss": 0.1, # loss for stopping process
    "pruning_percent_step": 0.05, # part of convs for delete on every pruning step
    "pruning_standart_deviation_part": 0.2 # shift for limit pruning part
}

Освен това е въведено ограничение, базирано на стандартното отклонение. Целта е да се ограничи частта, която се премахва, като се изключат навивки с вече „достатъчни“ L1 мерки:

По този начин ви позволяваме да премахвате само слаби навивки от дистрибуции, подобни на дясната, и да не засягаме премахването от дистрибуции, подобни на лявата:

Когато разпределението се доближи до нормалното, коефициентът pruning_standart_deviation_part може да бъде избран от:

Препоръчвам предположение за 2 сигма. Или можете да игнорирате тази функция, оставяйки стойност < 1.0.

Резултатът е графика на размера на мрежата, загубата и времето за работа на мрежата за целия тест, нормализирана до 1.0. Например, тук размерът на мрежата беше намален почти 2 пъти без загуба на качество (малка конволюционна мрежа със 100k тегла):

Скоростта на движение е обект на нормални колебания и остава практически непроменена. Има обяснение за това:

1. Броят на навивките се променя от удобен (32, 64, 128) до не най-удобен за видеокарти - 27, 51 и т.н. Тук може и да греша, но най-вероятно има ефект.
2. Архитектурата не е широка, но последователна. Намалявайки ширината, ние не влияем на дълбочината. Така намаляваме натоварването, но не променяме скоростта.

Следователно подобрението се изразява в намаляване на натоварването на CUDA по време на изпълнение с 20-30%, но не и в намаляване на времето за изпълнение

Резултати от

Нека да отразим. Разгледахме 2 варианта за съкращаване - за YOLOv3 (когато трябва да работите с ръцете си) и за мрежи с по-проста архитектура. Може да се види, че и в двата случая е възможно да се постигне намаляване на размера на мрежата и ускоряване без загуба на точност. Резултати:

• Намаляване на размера
• Бягане за ускорение
• Намаляване на натоварването на CUDA
• В резултат на това екологосъобразност (Ние оптимизираме бъдещото използване на компютърни ресурси. Някъде човек е щастлив Грета Тунберг)

Апендикс

• След стъпката на подрязване можете да добавите квантуване (например с TensorRT)
• Tensorflow предоставя възможности за ниско_магнитудно_подрязване. Върши работа.
• хранилище Искам да се развивам и ще се радвам да помогна

Източник: www.habr.com