ჯედაის ტექნიკა კონვოლუციური ქსელების შემცირებისთვის - მორთვა

სანამ ისევ არის ამოცანა აღმოჩენის ობიექტები. პრიორიტეტი არის ოპერაციის სიჩქარე მისაღები სიზუსტით. თქვენ იღებთ YOLOv3 არქიტექტურას და შემდგომ ავარჯიშებთ მას. სიზუსტე (mAp75) 0.95-ზე მეტია. მაგრამ გაშვების მაჩვენებელი მაინც დაბალია. სისულელე.

დღეს ჩვენ გვერდს ვუვლით კვანტიზაციას. და ჭრის ქვეშ ჩვენ შევხედავთ მოდელი Pruning — ქსელის ზედმეტი ნაწილების მორთვა, რათა დააჩქაროს დასკვნა სიზუსტის დაკარგვის გარეშე. გასაგებია სად, რამდენი და როგორ უნდა მოჭრა. მოდით გავარკვიოთ, როგორ გავაკეთოთ ეს ხელით და სად შეგიძლიათ მისი ავტომატიზაცია. დასასრულს არის საცავი კერაზე.

შესავალი

ჩემს წინა სამუშაო ადგილზე, მაკროსკოპში პერმში, შევიძინე ერთი ჩვევა - ყოველთვის ვაკონტროლო ალგორითმების შესრულების დრო. და ყოველთვის შეამოწმეთ ქსელის მუშაობის დრო ადეკვატურობის ფილტრის მეშვეობით. როგორც წესი, წარმოების უახლესი ტექნოლოგია არ გადის ამ ფილტრს, რამაც მიმიყვანა Pruning-მდე.

გასხვლა ძველი თემაა, რომელზეც განიხილეს სტენფორდის ლექციებს 2017 წელს. მთავარი იდეა არის გაწვრთნილი ქსელის ზომის შემცირება სიზუსტის დაკარგვის გარეშე სხვადასხვა კვანძების ამოღებით. მაგრად ჟღერს, მაგრამ იშვიათად მესმის მისი გამოყენების შესახებ. ალბათ, არ არის საკმარისი იმპლემენტაციები, არ არის რუსულენოვანი სტატიები, ან უბრალოდ ყველა ამას ნოუ-ჰაუს მიაჩნია და დუმს.
მაგრამ მოდით ეს ცალკე

მიმოხილვა ბიოლოგიაში

მე მიყვარს, როდესაც Deep Learning უყურებს იდეებს, რომლებიც მომდინარეობს ბიოლოგიიდან. მათ, ისევე როგორც ევოლუციას, შეიძლება ენდოთ (იცოდით რომ ReLU ძალიან ჰგავს თავის ტვინში ნეირონების აქტივაციის ფუნქცია?)

მოდელი Pruning პროცესი ასევე ახლოს არის ბიოლოგიასთან. ქსელის პასუხი აქ შეიძლება შევადაროთ ტვინის პლასტიურობას. წიგნში არის რამდენიმე საინტერესო მაგალითი. ნორმან დოიჯი:

1. ქალის ტვინმა, რომელიც მხოლოდ ერთი ნახევრით დაიბადა, გადაპროგრამა საკუთარი თავი დაკარგული ნახევრის ფუნქციების შესასრულებლად.
2. ბიჭმა მოისროლა თავის ტვინის ნაწილი, რომელიც პასუხისმგებელია მხედველობაზე. დროთა განმავლობაში, ტვინის სხვა ნაწილებმა აიღეს ეს ფუნქციები. (ჩვენ არ ვცდილობთ გავიმეოროთ)

ანალოგიურად, თქვენ შეგიძლიათ ამოიღოთ ზოგიერთი სუსტი კონვოლუცია თქვენი მოდელიდან. როგორც ბოლო საშუალება, დარჩენილი ჩალიჩები ხელს შეუწყობს მოჭრილი ჩალიჩების შეცვლას.

გიყვართ ტრანსფერული სწავლება თუ ნულიდან სწავლობთ?

ვარიანტი ნომერი პირველი. თქვენ იყენებთ Transfer Learning-ს Yolov3-ზე. Retina, Mask-RCNN ან U-Net. მაგრამ უმეტეს შემთხვევაში ჩვენ არ გვჭირდება 80 ობიექტის კლასის ამოცნობა, როგორც COCO-ში. ჩემს პრაქტიკაში ყველაფერი შემოიფარგლება 1-2 კლასებით. შეიძლება ვივარაუდოთ, რომ 80 კლასის არქიტექტურა აქ ზედმეტია. ეს იმაზე მეტყველებს, რომ არქიტექტურა უფრო დაპატარავებული უნდა იყოს. უფრო მეტიც, მინდა ამის გაკეთება არსებული წინასწარ მომზადებული წონების დაკარგვის გარეშე.

ვარიანტი ნომერი ორი. შესაძლოა, თქვენ გაქვთ ბევრი მონაცემი და გამოთვლითი რესურსი, ან უბრალოდ გჭირდებათ სუპერმორგებული არქიტექტურა. არ აქვს მნიშვნელობა. მაგრამ თქვენ სწავლობთ ქსელს ნულიდან. ჩვეულებრივი პროცედურაა მონაცემთა სტრუქტურის დათვალიერება, არქიტექტურის არჩევა, რომელიც ჭარბი სიმძლავრით არის და აიძულებს აბიტურიენტებს გადამზადებისგან. მე ვნახე 0.6 მიტოვებული, კარლ.

ორივე შემთხვევაში, ქსელი შეიძლება შემცირდეს. მოტივირებული. ახლა მოდით გავარკვიოთ, რა არის წინადაცვეთა გასხვლა

ზოგადი ალგორითმი

ჩვენ გადავწყვიტეთ, რომ შეგვეძლო ჩალიჩების ამოღება. საკმაოდ მარტივად გამოიყურება:

ნებისმიერი კონვოლუციის ამოღება სტრესულია ქსელისთვის, რაც ჩვეულებრივ იწვევს შეცდომის გარკვეულ ზრდას. ერთის მხრივ, შეცდომის ეს ზრდა არის მაჩვენებელი იმისა, თუ რამდენად სწორად ვხსნით კონვოლუციებს (მაგალითად, დიდი ზრდა მიუთითებს იმაზე, რომ ჩვენ რაღაცას არასწორად ვაკეთებთ). მაგრამ მცირე ზრდა საკმაოდ მისაღებია და ხშირად აღმოიფხვრება შემდგომი მსუბუქი დამატებითი ვარჯიშით მცირე LR-ით. დაამატეთ ტრენინგის დამატებითი ეტაპი:

ახლა ჩვენ უნდა გავარკვიოთ, როდის გვინდა შევწყვიტოთ Learning<->Pruning loop. აქ შეიძლება იყოს ეგზოტიკური ვარიანტები, როდესაც ჩვენ გვჭირდება ქსელის შემცირება გარკვეულ ზომამდე და სიჩქარეზე (მაგალითად, მობილური მოწყობილობებისთვის). თუმცა, ყველაზე გავრცელებული ვარიანტია ციკლის გაგრძელება მანამ, სანამ შეცდომა არ გახდება უფრო მაღალი ვიდრე მისაღები. დაამატე პირობა:

ასე რომ, ალგორითმი ნათელი ხდება. რჩება იმის გარკვევა, თუ როგორ უნდა დადგინდეს წაშლილი კონვოლუციები.

მოძებნეთ წაშლილი პაკეტები

ჩვენ უნდა მოვიშოროთ რამდენიმე კონვოლუცია. წინ ჩქარობა და ვინმეს „გასროლა“ ცუდი იდეაა, თუმცა იმუშავებს. მაგრამ რადგან თქვენ გაქვთ თავი, შეგიძლიათ იფიქროთ და სცადოთ აირჩიოთ "სუსტი" კონვოლუციები მოსაშორებლად. რამდენიმე ვარიანტია:

1. ყველაზე პატარა L1-საზომი ან დაბალი_მაგნიტუდის_გასხვლა. იდეა, რომ კონვოლუციები მცირე წონებით მცირე წვლილი შეაქვს საბოლოო გადაწყვეტილებაში
2. ყველაზე პატარა L1- საზომი საშუალო და სტანდარტული გადახრის გათვალისწინებით. ჩვენ ვავსებთ განაწილების ბუნების შეფასებას.
3. კონვოლუციების ნიღაბი და მათი გამორიცხვა, რომლებიც ყველაზე ნაკლებ გავლენას ახდენენ საბოლოო სიზუსტეზე. უმნიშვნელო კონვოლუციების უფრო ზუსტი განსაზღვრა, მაგრამ ძალიან შრომატევადი და რესურსი.
4. სხვა

თითოეულ ვარიანტს აქვს სიცოცხლის უფლება და საკუთარი განხორციელების მახასიათებლები. აქ განვიხილავთ ვარიანტს ყველაზე პატარა L1 ზომით

მექანიკური პროცესი YOLOv3-ისთვის

ორიგინალური არქიტექტურა შეიცავს ნარჩენ ბლოკებს. მაგრამ რაც არ უნდა მაგარი იყოს ღრმა ქსელებისთვის, გარკვეულწილად შეგვაფერხებენ. სირთულე ის არის, რომ თქვენ არ შეგიძლიათ წაშალოთ შერიგებები სხვადასხვა ინდექსებით ამ ფენებში:

ამიტომ, მოდით ავირჩიოთ ფენები, საიდანაც შეგვიძლია თავისუფლად წავშალოთ შერიგებები:

ახლა ავაშენოთ სამუშაო ციკლი:

1. მიმდინარეობს აქტივაციების ატვირთვა
2. გაერკვია რამდენი უნდა მოჭრა
3. Ამოჭრა
4. 10 ეპოქის სწავლა LR=1e-4-ით
5. ტესტირება

კონვოლუციების გადმოტვირთვა სასარგებლოა იმის შესაფასებლად, თუ რამდენი ნაწილის ამოღება შეგვიძლია გარკვეულ საფეხურზე. გადმოტვირთვის მაგალითები:

ჩვენ ვხედავთ, რომ კონვოლუციების თითქმის ყველგან 5%-ს აქვს ძალიან დაბალი L1-ნორმა და ჩვენ შეგვიძლია მათი ამოღება. ყოველ საფეხურზე ეს გადმოტვირთვა მეორდებოდა და კეთდებოდა შეფასება, თუ რომელი ფენების და რამდენის ამოჭრა შეიძლებოდა.

მთელი პროცესი დასრულდა 4 ნაბიჯში (ნომრები აქ და ყველგან RTX 2060 Super-ისთვის):

ნაბიჯი	mAp75	პარამეტრების რაოდენობა, მლნ	ქსელის ზომა, მბ	საწყისიდან, %	გაშვების დრო, ms	წინადაცვეთა მდგომარეობა
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-ჯერ შემცირდა ხარისხის დაკარგვის გარეშე (პატარა კონვოლუციური ქსელი 100 ათასი წონით):

მუშაობის სიჩქარე ექვემდებარება ნორმალურ რყევებს და პრაქტიკულად უცვლელი რჩება. ამის ახსნა არსებობს:

1. კონვოლუციების რაოდენობა იცვლება მოსახერხებელიდან (32, 64, 128) არა ყველაზე მოსახერხებელი ვიდეო ბარათებისთვის - 27, 51 და ა.შ. აქ შეიძლება ვცდებოდე, მაგრამ დიდი ალბათობით მას აქვს ეფექტი.
2. არქიტექტურა არ არის ფართო, მაგრამ თანმიმდევრული. სიგანის შემცირებით ჩვენ არ ვმოქმედებთ სიღრმეზე. ამრიგად, ჩვენ ვამცირებთ დატვირთვას, მაგრამ არ ვცვლით სიჩქარეს.

აქედან გამომდინარე, გაუმჯობესება გამოიხატა CUDA დატვირთვის შემცირებაში გაშვების დროს 20-30%-ით, მაგრამ არა მუშაობის დროის შემცირებაში.

შედეგები

მოდით ასახული. ჩვენ განვიხილეთ გასხვლის 2 ვარიანტი - YOLOv3-ისთვის (როდესაც ხელით გიწევთ მუშაობა) და უფრო მარტივი არქიტექტურის მქონე ქსელებისთვის. ჩანს, რომ ორივე შემთხვევაში შესაძლებელია ქსელის ზომის შემცირება და დაჩქარება სიზუსტის დაკარგვის გარეშე. შედეგები:

• ზომის შემცირება
• აჩქარების გაშვება
• CUDA დატვირთვის შემცირება
• შედეგად, გარემოსდაცვითი კეთილგანწყობა (ჩვენ ვაუმჯობესებთ გამოთვლითი რესურსების სამომავლო გამოყენებას. სადღაც ადამიანი ბედნიერია გრეტა ტუნბერგი)

დანართი

• გასხვლის ეტაპის შემდეგ შეგიძლიათ დაამატოთ კვანტიზაცია (მაგალითად, TensorRT-ით)
• Tensorflow უზრუნველყოფს შესაძლებლობებს დაბალი_მაგნიტუდის_ გასხვლა. სამუშაოები.
• საცავი მინდა განვვითარდე და სიამოვნებით დაგეხმარები

წყარო: www.habr.com