Джедайска техника за намаляване на свръхслойните мрежи — pruning

Пред теб отново има задача за откриване на обекти. Приоритет — скорост на работа при приемлива точност. Избираш архитектурата YOLOv3 и я дообучаваш. Точността (mAp75) е над 0.95. Но скоростта на изпълнение все още е ниска. Черт.

Днес ще пропуснем квантизацията. А под кат ще разгледаме Model Pruning — премахване на излишните части от мрежата за ускоряване на инференцията, без загуба на точност. Нагледно — откъде, колко и как може да се изреже. Ще разгледаме как да го направим ръчно и къде можем да автоматизираме. В края — хранилище на keras.

Въведение

На предишното ми работно място, в пермския Macroscop, придобих навика да следя времето за изпълнение на алгоритмите. А времето за изпълнение на мрежите винаги да се проверява чрез филтър за адекватност. Обикновено state-of-the-art в продукция не минават този филтър, което ме доведе до Pruning.

Pruning — стара тема, за която говориха на стенфордските лекции през 2017 година. Основната идея е намаляване на размера на обучената мрежа без загуба на точност чрез премахване на различни възли. Звучи яко, но рядко чувам за неговото приложение. Може би липсват имплементации, няма руски статии или просто всички смятат, че pruning е ноу-хау и мълчат.
Но да разгледаме

Поглед в биологията

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

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

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

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

Любиш ли Transfer Learning или учиш от нулата?

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

Вариант номер две. Може би имаш много данни и изчислителни ресурси или просто нужда от свръхкъстомизирана архитектура. Няма значение. Но учиш мрежата от нулата. Обичаен ред — гледаме на структурата на данните, подбираме излишна по мощност архитектура и добавяме дропаут от пренатоварване. Видях дропаут от 0.6, Карл.

В двата случая мрежата може да се намалява. Мотивирано. Сега да разгледаме какво представлява прерязването pruning.

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

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

Премахването на всяка свертка е стрес за мрежата, който обикновено води и до известно покачване на грешката. От една страна, това покачване на грешката е показател за това, колко правилно премахваме свертките (например, голямото покачване говори, че не правим нещо както трябва). Но малкото покачване е напълно допустимо и често се неутрализира с последващо леко дообучение с малък 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):

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

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

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

Тази версия я внедрих. тук.
Всичко е просто: от вас само функция на загубата, оптимизатор и генератори на пакети:

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, # броят на епохите за обучение между стъпките на рязане
    "stop_loss": 0.1, # загуба за спиране на процеса
    "pruning_percent_step": 0.05, # част от свертките, които ще се изтриват на всяка стъпка на рязане
    "pruning_standart_deviation_part": 0.2 # отклонение за лимитиране на рязането
}

Допълнително е реализирано ограничение, основано на стандартното отклонение. Целта е да се ограничи частта, която се изтрива, изключвайки свертки с вече "достатъчни" L1 мерки:

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

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

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

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

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

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

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

Резюме

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

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

Appendix

• След стъпката на рязане може да се добави и квантизация (например с TensorRT)
• Tensorflow предлага възможности за low_magnitude_pruning. Работи.
• Репозиторий искам да развивам и ще се радвам на помощ

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