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

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

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

Въведение

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

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

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

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

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

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

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

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

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
• Като следствие, екологичност (Оптимизираме бъдещото използване на изчислителни ресурси. Някъде радва една Грета Тунберг)

Приложение

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

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