Jedi-Technik zur Reduzierung von konvolutionalen Netzen — Pruning

Vor dir steht wieder die Aufgabe der Objekterkennung. Priorität hat die Arbeitsgeschwindigkeit bei akzeptabler Genauigkeit. Du nimmst die Architektur YOLOv3 und bildest sie weiter. Die Genauigkeit (mAp75) liegt über 0,95. Aber die Laufgeschwindigkeit ist immer noch niedrig. Verdammt.

Heute umgehen wir die Quantisierung. Im Nachfolgenden betrachten wir Model Pruning — das Entfernen überflüssiger Teile des Netzwerks zur Beschleunigung der Inferenz ohne Verlust der Genauigkeit. Verdeutlicht wird, wo, wie viel und wie man schneiden kann. Wir werden untersuchen, wie man dies manuell durchführt und wo Automatisierung möglich ist. Am Ende — ein Repository auf Keras.

Einführung

An meinem vorherigen Arbeitsplatz, dem permischen Macroscop, habe ich mir eine Gewohnheit angeeignet — immer die Ausführungszeit der Algorithmen zu überwachen. Die Laufzeit der Netzwerke überprüfe ich immer durch einen Angemessenheitsfilter. Normalerweise bestehen state-of-the-art Modelle diesen Filter nicht, was mich zum Pruning geführt hat.

Pruning — ein altes Thema, das in den Stanford-Vorlesungen im Jahr 2017 behandelt wurde. Die Hauptidee ist die Reduzierung der Größe eines trainierten Netzwerks, ohne die Genauigkeit zu verlieren, indem verschiedene Knoten entfernt werden. Klingt cool, aber ich höre selten von seiner Anwendung. Wahrscheinlich fehlen Umsetzungen, es gibt keine russischsprachigen Artikel oder alle halten Pruning einfach für ein Geheimnis und schweigen.
Aber lass uns das betrachten.

Ein Blick in die Biologie

Ich liebe es, wenn im Deep Learning Ideen aus der Biologie aufblitzen. Ihnen, wie der Evolution, kann man vertrauen (wusstest du, dass ReLU sehr ähnlich ist wie die Aktivierungsfunktion von Neuronen im Gehirn?)

Der Prozess des Model Pruning ist auch nahe an der Biologie. Die Reaktion des Netzwerks hier kann mit der Plastizität des Gehirns verglichen werden. Einige interessante Beispiele finden sich im Buch von Norman Doidge.:

1. Das Gehirn einer Frau, die von Geburt an nur eine Gehirnhälfte hatte, hat sich selbst umprogrammiert, um die Funktionen der fehlenden Hälfte auszuführen.
2. Ein Junge hat sich einen Teil seines Gehirns entfernt, der für das Sehen verantwortlich war. Im Laufe der Zeit haben andere Teile des Gehirns diese Funktionen übernommen. (Wiederholen wir nicht.)

So kann auch aus deinem Modell ein Teil schwacher Faltungen entfernt werden. Im schlimmsten Fall können die verbleibenden Faltungen die entfernten ersetzen.

Liebst du Transfer Learning oder lernst du von Grund auf neu?

Option Nummer eins. Du verwendest Transfer Learning für Yolov3. Retina, Mask-RCNN oder U-Net. Aber meistens müssen wir nicht 80 Klassen von Objekten erkennen, wie in COCO. In meiner Praxis beschränken sich die Klassen auf 1-2. Man könnte annehmen, dass die Architektur für 80 Klassen hier überdimensioniert ist. Es liegt nahe, die Architektur zu reduzieren. Und das möchte ich gerne tun, ohne die vorhandenen vortrainierten Gewichte zu verlieren.

Variante Nummer zwei. Vielleicht hast du viele Daten und Rechenressourcen oder brauchst einfach eine super individuelle Architektur. Egal. Aber du trainierst das Netzwerk von Grund auf. Der übliche Ablauf — wir schauen uns die Datenstruktur an, wählen eine ÜBERDIMENSIONIERTE Architektur aus und drücken Dropouts gegen Überanpassung. Ich habe Dropouts von 0.6 gesehen, Karl.

In beiden Fällen kann das Netzwerk verkleinert werden. Das waren die Anreize. Jetzt lass uns klären, was es mit dem Pruning auf sich hat.

Allgemeiner Algorithmus

Wir haben beschlossen, dass wir Faltungen entfernen können. Das sieht ziemlich einfach aus:

Die Entfernung einer beliebigen Faltung ist ein Stress für das Netzwerk, der normalerweise mit einem gewissen Anstieg des Fehlers einhergeht. Einerseits ist dieser Anstieg des Fehlers ein Maß dafür, wie korrekt wir die Faltungen entfernen (zum Beispiel zeigt ein großer Anstieg, dass wir etwas falsch machen). Aber ein kleiner Anstieg ist durchaus akzeptabel und wird oft durch anschließendes leichtes Nachtraining mit einem niedrigen LR behoben. Wir fügen einen Schritt zum Nachtraining hinzu:

Jetzt müssen wir verstehen, wann wir unseren Zyklus Learning<->Pruning stoppen wollen. Hier kann es exotische Fälle geben, in denen wir das Netzwerk auf eine bestimmte Größe und Geschwindigkeit reduzieren müssen (zum Beispiel für mobile Geräte). Der häufigste Fall ist jedoch, dass wir den Zyklus fortsetzen, bis der Fehler den zulässigen Wert überschreitet. Wir fügen eine Bedingung hinzu:

So wird der Algorithmus klar. Es bleibt zu klären, wie wir die zu entfernenden Faltungen bestimmen.

Suche nach zu entfernenden Faltungen

Wir müssen einige Faltungen entfernen. Einfach unverblümt „wegzuschießen“ ist keine gute Idee, auch wenn es funktioniert. Aber wenn man einen Kopf hat, kann man nachdenken und versuchen, „schwache“ Faltungen herauszufiltern, die man entfernen kann. Es gibt mehrere Optionen:

1. Kleinster L1-Maßstab oder low_magnitude_pruning. Die Idee besagt, dass Faltungen mit kleinen Gewichtswerten, einen geringen Beitrag zur endgültigen Entscheidungsfindung leisten.
2. Kleinster L1-Maßstab unter Berücksichtigung von Mittelwert und Standardabweichung. Wir ergänzen die Bewertung der Verteilung.
3. Maskierung von Faltungen und Ausschluss der am wenigsten einflussreichen auf die Gesamtabweichung. Eine genauere Bestimmung der unwesentlichen Faltungen, jedoch zeit- und ressourcenintensiv.
4. Andere

Jede der Varianten hat das Recht auf Existenz und eigene Umsetzungsmerkmale. Hier betrachten wir die Variante mit der kleinsten L1-Metrik

Manueller Prozess für YOLOv3

In der ursprünglichen Architektur sind Residualblöcke enthalten. Doch egal wie beeindruckend sie für tiefe Netzwerke sind, sie stören uns etwas. Das Problem ist, dass Faltungen mit unterschiedlichen Indizes in diesen Schichten nicht entfernt werden können:

Deshalb bestimmen wir die Schichten, aus denen wir Faltungen frei entfernen können:

Jetzt erstellen wir den Arbeitszyklus:

1. Wir laden die Aktivierungen hoch
2. Wir schätzen ein, wie viel ausgeschnitten werden soll
3. Wir schneiden aus
4. Wir trainieren 10 Epochen mit LR=1e-4
5. Wir testen

Das Entfernen der Faltungen ist nützlich, um zu bewerten, welchen Teil wir in einem bestimmten Schritt entfernen können. Beispiele für das Entfernen:

Wir sehen, dass fast überall 5% der Faltungen eine sehr niedrige L1-Norm aufweisen und wir sie entfernen können. In jedem Schritt wurde solch ein Entfernen wiederholt und eine Bewertung durchgeführt, aus welchen Schichten und wie viel entfernt werden kann.

Der gesamte Prozess war in 4 Schritte unterteilt (hier und überall die Zahlen für RTX 2060 Super):

Zu Schritt 2 kam ein positiver Effekt hinzu – eine Batch-Größe von 4 passte in den Speicher, was den Prozess des weiteren Trainings erheblich beschleunigte.
Im Schritt 4 wurde der Prozess gestoppt, da auch ein längeres weiteres Training mAp75 nicht auf die alten Werte erhöhen konnte.
Letztendlich konnte der Inferenzprozess beschleunigt werden um 15%, die Größe reduziert werden um 35% und es ging keine Genauigkeit verloren.

Automatisierung für einfachere Architekturen

Für einfachere Netzwerkarchitekturen (ohne bedingte add, concatenate und residual Blöcke) kann man sich ganz auf die Verarbeitung aller Faltungsschichten konzentrieren und den Prozess des Ausschneidens von Faltungen automatisieren.

Solch eine Variante habe ich implementiert hier.
Es ist ganz einfach: Sie benötigen nur die Verlustfunktion, den Optimierer und die Batch-Generatoren:

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)

Falls nötig, können die Konfigurationsparameter geändert werden:

{
    "input_model_path": "model.h5",
    "output_model_path": "model_pruned.h5",
    "finetuning_epochs": 10, # die Anzahl der Epochen zum Trainieren zwischen den Pruning-Schritten
    "stop_loss": 0.1, # Verlust zum Stoppen des Prozesses
    "pruning_percent_step": 0.05, # Anteil der Konvolutionen, die bei jedem Pruning-Schritt gelöscht werden
    "pruning_standart_deviation_part": 0.2 # Verschiebung zur Begrenzung des Pruning-Anteils
}

Zusätzlich wurde eine Einschränkung basierend auf der Standardabweichung implementiert. Ziel ist es, den Teil der zu löschenden Elemente zu begrenzen, wobei Konvolutionen mit bereits "ausreichenden" L1-Maßen ausgeschlossen werden:

Damit erlauben wir es, nur schwache Konvolutionen aus Verteilungen ähnlich der rechten zu löschen und nicht die Löschung aus Verteilungen ähnlich der linken zu beeinflussen:

Bei der Annäherung der Verteilung an die Normalverteilung kann der Koeffizient pruning_standart_deviation_part ausgewählt werden aus:

Ich empfehle eine Toleranz von 2 Sigma. Alternativ kann man diese Besonderheit ignorieren und den Wert < 1.0 belassen.

Das Ergebnis ist ein Diagramm der Netzwerkgröße, Verluste und der Laufzeit des Netzwerks über den gesamten Test, normiert auf 1.0. Zum Beispiel wurde hier die Netzwerkgröße fast halbiert, ohne an Qualität zu verlieren (ein kleines Convolutional-Netzwerk mit 100k Gewichten):

Die Laufgeschwindigkeit unterliegt normalen Schwankungen und hat sich praktisch nicht verändert. Das hat einen Grund:

1. Die Anzahl der Konvolutionen wechselt von bequemen (32, 64, 128) zu weniger bequemen für Grafikkarten — 27, 51 usw. Hier kann ich mich irren, aber wahrscheinlich hat das einen Einfluss.
2. Die Architektur ist nicht breit, sondern durchgängig. Indem wir die Breite reduzieren, ändern wir nicht die Tiefe. So verringern wir die Last, ohne die Geschwindigkeit zu beeinflussen.

Daher zeigt sich die Verbesserung in der Reduzierung der CUDA-Last beim Durchlauf um 20-30%, jedoch nicht in der Verringerung der Durchlaufzeit.

Ergebnisse

Lass uns reflektieren. Wir haben zwei Varianten des Pruning betrachtet — für YOLOv3 (wenn man manuell arbeiten muss) und für Netzwerke mit einfacheren Architekturen. Es ist klar, dass in beiden Fällen eine Verringerung der Netzwerkgröße und Beschleunigung ohne Verlust an Genauigkeit erreicht werden kann. Ergebnisse:

• Verringerung der Größe
• Beschleunigung des Durchlaufs
• Verringerung der CUDA-Last
• Als Folge davon ist die Umweltfreundlichkeit (Wir optimieren die zukünftige Nutzung von Rechenressourcen. Irgendwo freut sich eine Greta Thunberg)

Anhang

• Nach dem Pruning-Schritt kann noch Quantisierung hinzugefügt werden (zum Beispiel mit TensorRT)
• Tensorflow bietet Möglichkeiten für low_magnitude_pruning. Es funktioniert.
• Repository Ich möchte mich weiterentwickeln und freue mich über Hilfe.

Quelle: habr.com