{"id":54494,"date":"2019-12-27T00:00:00","date_gmt":"2019-12-26T21:00:00","guid":{"rendered":"https:\/\/prohoster.info\/blog\/blog_prohoster\/dzhedajskaya-tehnika-umensheniya-svertochnyh-setej-pruning"},"modified":"2020-02-18T14:02:30","modified_gmt":"2020-02-18T11:02:30","slug":"dzhedajskaya-tehnika-umensheniya-svertochnyh-setej-pruning","status":"publish","type":"post","link":"https:\/\/prohoster.info\/de\/blog\/novosti-interneta\/dzhedajskaya-tehnika-umensheniya-svertochnyh-setej-pruning","title":{"rendered":"Die Jedi-Technik zur Reduzierung von Convolutional Networks \u2014 Pruning","gt_translate_keys":[{"key":"rendered","format":"text"}]},"content":{"rendered":"

\"Die<\/p>\n

<\/p>\n

Du stehst erneut vor der Aufgabe der Objekterkennung. Priorit\u00e4t hat die Geschwindigkeit bei akzeptabler Genauigkeit. Du nimmst die Architektur YOLOv3 und feinstimmst sie. Genauigkeit (mAp75) \u00fcber 0,95. Doch die Geschwindigkeit ist immer noch niedrig. Verdammt. <\/p>\n

<\/p>\n

Heute lassen wir die Quantisierung beiseite. Im Anschluss betrachten wir Model Pruning<\/strong> \u2014 das Entfernen \u00fcberfl\u00fcssiger Teile des Netzwerks zur Beschleunigung der Inferenz bei Erhaltung der Genauigkeit. Anschaulich \u2014 wo, wie viel und wie kann ausgeschnitten werden. Wir werden besprechen, wie man dies manuell macht und wo man es automatisieren kann. Am Ende \u2014 ein Repository f\u00fcr Keras.<\/p>\n

<\/a><\/noindex><\/p>\n

Einf\u00fchrung<\/h3>\n

<\/p>\n

Bei meinem vorherigen Arbeitgeber, dem Permer Macroscop, habe ich mir eine Angewohnheit angeeignet \u2014 stets die Laufzeit der Algorithmen zu \u00fcberwachen. Und die Laufzeit der Netzwerke immer \u00fcber einen Angemessenheitsfilter zu \u00fcberpr\u00fcfen. In der Regel bestehen state-of-the-art Modelle in der Produktion diesen Filter nicht, was mich zum Pruning gef\u00fchrt hat. <\/p>\n

<\/p>\n

Pruning \u2014 ein altes Thema, das in den Stanford-Vorlesungen behandelt wurde.<\/a><\/noindex> Im Jahr 2017. Die grundlegende Idee ist, die Gr\u00f6\u00dfe des trainierten Netzwerks zu verringern, ohne dass die Genauigkeit leidet, indem verschiedene Knoten entfernt werden. Klingt cool, aber ich h\u00f6re selten von seiner Anwendung. Wahrscheinlich mangelt es an Implementierungen, es gibt keine deutschsprachigen Artikel oder einfach alle halten pruning f\u00fcr ein Geheimnis und schweigen.
\nAber lass uns das auseinandernehmen.<\/p>\n

<\/p>\n

Ein Blick in die Biologie<\/h3>\n

<\/p>\n

Ich liebe es, wenn Ideen aus der Biologie im Deep Learning Anwendung finden. Auf sie, ebenso wie auf die Evolution, kann man vertrauen (wusstest du, dass ReLU sehr \u00e4hnlich ist wie die Aktivierungsfunktion von Neuronen im Gehirn?<\/a><\/noindex>?) <\/p>\n

<\/p>\n

Der Prozess des Model Pruning ist ebenfalls eng mit der Biologie verbunden. Die Reaktion des Netzwerks l\u00e4sst sich mit der Plastizit\u00e4t des Gehirns vergleichen. Einige interessante Beispiele findet man im Buch von Norman Doidge.<\/a><\/noindex>:<\/p>\n

<\/p>\n

    \n
  1. Das Gehirn einer Frau, die von Geburt an nur eine Gehirnh\u00e4lfte hatte, hat sich selbst umprogrammiert, um die Funktionen der fehlenden H\u00e4lfte auszuf\u00fchren.<\/li>\n
  2. Ein Mann hatte sich einen Teil seines Gehirns entfernt, der f\u00fcr das Sehen verantwortlich war. Im Laufe der Zeit \u00fcbernahmen andere Teile des Gehirns diese Funktionen. (Wir versuchen nicht, das zu wiederholen.)<\/li>\n<\/ol>\n

    <\/p>\n

    So kann auch aus deinem Modell ein Teil schwacher Schichten entfernt werden. Im Zweifelsfall helfen die verbleibenden Schichten, die entfernten zu ersetzen. <\/p>\n

    <\/p>\n

    Liebst du Transfer Learning oder lernst du von Grund auf?<\/h3>\n

    <\/p>\n

    Option Nummer eins.<\/strong> Sie nutzen Transfer Learning mit Yolov3, Retina, Mask-RCNN oder U-Net. Doch h\u00e4ufig m\u00fcssen wir nicht 80 Objektklassen wie im COCO-Datensatz erkennen. In meiner Erfahrung beschr\u00e4nkt sich das alles auf 1-2 Klassen. Man k\u00f6nnte annehmen, dass die Architektur f\u00fcr 80 Klassen hier \u00fcbertrieben ist. Daher liegt der Gedanke nahe, die Architektur zu verkleinern. Und das m\u00f6chte ich gerne tun, ohne die bestehenden vortrainierten Gewichte zu verlieren.<\/p>\n

    <\/p>\n

    Option Nummer zwei.<\/strong> Vielleicht haben Sie viele Daten und Rechenressourcen oder ben\u00f6tigen einfach eine hochgradig angepasste Architektur. Das ist irrelevant. Aber Sie trainieren das Netzwerk von Grund auf. Der \u00fcbliche Ablauf besteht darin, sich die Datenstruktur anzusehen, eine \u00dcBERFL\u00dcSSIGE leistungsstarke Architektur auszuw\u00e4hlen und Dropouts gegen \u00dcberanpassung anzuwenden. Ich habe Dropouts von 0.6 gesehen, Karl. <\/p>\n

    <\/p>\n

    In beiden F\u00e4llen l\u00e4sst sich das Netzwerk verkleinern. Wir haben einen Grund daf\u00fcr formuliert. Jetzt wollen wir herausfinden, was es mit dem Pruning auf sich hat.<\/p>\n

    <\/p>\n

    Algorithmus insgesamt<\/h3>\n

    <\/p>\n

    Wir haben entschieden, dass wir Faltungen entfernen k\u00f6nnen. Das sieht ziemlich einfach aus:<\/p>\n

    <\/p>\n

    \"Die<\/p>\n

    <\/p>\n

    Das Entfernen von Faltungen belastet das Netzwerk und f\u00fchrt in der Regel zu einem gewissen Anstieg der Fehlerquote. Einerseits zeigt dieser Anstieg, wie gut wir die Faltungen entfernen (ein gro\u00dfer Anstieg deutet darauf hin, dass wir etwas falsch machen). Ein kleiner Anstieg ist jedoch durchaus akzeptabel und kann oft durch anschlie\u00dfendes leichtes Nachtraining mit einer kleinen Lernrate behoben werden. F\u00fcgen wir einen Nachtrainingsschritt hinzu:<\/p>\n

    <\/p>\n

    \"Die<\/p>\n

    <\/p>\n

    Jetzt m\u00fcssen wir verstehen, wann wir unseren Lern-Pruning-Zyklus stoppen m\u00f6chten. Es kann exotische Szenarien geben, in denen wir das Netzwerk auf eine bestimmte Gr\u00f6\u00dfe und Geschwindigkeit reduzieren m\u00fcssen (z. B. f\u00fcr mobile Ger\u00e4te). Das h\u00e4ufigste Szenario ist jedoch das Fortsetzen des Zyklus, bis der Fehler \u00fcber den akzeptablen Wert steigt. F\u00fcgen wir eine Bedingung hinzu:<\/p>\n

    <\/p>\n

    \"Die<\/p>\n

    <\/p>\n

    Somit wird der Algorithmus klar. Es bleibt zu kl\u00e4ren, wie die zu entfernenden Faltungen identifiziert werden.<\/p>\n

    <\/p>\n

    Suche nach entfernbaren Faltungen<\/h3>\n

    <\/p>\n

    \u041d\u0430\u043c \u043d\u0443\u0436\u043d\u043e \u0443\u0434\u0430\u043b\u0438\u0442\u044c \u043a\u0430\u043a\u0438\u0435-\u0442\u043e \u0441\u0432\u0435\u0440\u0442\u043a\u0438. \u0420\u0432\u0430\u0442\u044c\u0441\u044f \u043d\u0430\u043f\u0440\u043e\u043b\u043e\u043c \u0438 «\u043e\u0442\u0441\u0442\u0440\u0435\u043b\u0438\u0432\u0430\u0442\u044c» \u043b\u044e\u0431\u044b\u0435 \u2014 \u043f\u043b\u043e\u0445\u0430\u044f \u0438\u0434\u0435\u044f, \u0445\u043e\u0442\u044c \u0438 \u0431\u0443\u0434\u0435\u0442 \u0440\u0430\u0431\u043e\u0442\u0430\u0442\u044c. \u041d\u043e \u0440\u0430\u0437 \u0435\u0441\u0442\u044c \u0433\u043e\u043b\u043e\u0432\u0430, \u043c\u043e\u0436\u043d\u043e \u043f\u043e\u0434\u0443\u043c\u0430\u0442\u044c \u0438 \u043f\u043e\u043f\u044b\u0442\u0430\u0442\u044c\u0441\u044f \u0432\u044b\u0434\u0435\u043b\u0438\u0442\u044c \u0434\u043b\u044f \u0443\u0434\u0430\u043b\u0435\u043d\u0438\u044f «\u0441\u043b\u0430\u0431\u044b\u0435» \u0441\u0432\u0435\u0440\u0442\u043a\u0438. \u0412\u0430\u0440\u0438\u0430\u043d\u0442\u043e\u0432 \u0435\u0441\u0442\u044c \u043d\u0435\u0441\u043a\u043e\u043b\u044c\u043a\u043e:<\/p>\n

    <\/p>\n

      \n
    1. Die kleinste L1-Metrik oder Low-Magnitude-Pruning<\/a><\/noindex>. Die Idee besagt, dass Faltungen mit geringen Gewichtswerten nur einen kleinen Einfluss auf die endg\u00fcltige Entscheidungsfindung haben. <\/li>\n
    2. Die kleinste L1-Metrik unter Ber\u00fccksichtigung des Mittelwerts und der Standardabweichung. Erg\u00e4nzt durch eine Bewertung der Verteilungsart.<\/li>\n
    3. Maskierung von Faltungen und Ausschluss der am wenigsten relevanten f\u00fcr die endg\u00fcltige Genauigkeit.<\/a><\/noindex>. Eine genauere Bestimmung von unbedeutenden Faltungen, aber sehr zeit- und ressourcenintensiv. <\/li>\n
    4. Andere <\/li>\n<\/ol>\n

      <\/p>\n

      Jede der Varianten hat ihre Daseinsberechtigung und spezifische Implementierungsmerkmale. Hier betrachten wir die Variante mit der kleinsten L1-Metrik.<\/p>\n

      <\/p>\n

      Manueller Prozess f\u00fcr YOLOv3<\/h3>\n

      <\/p>\n

      Die urspr\u00fcngliche Architektur enth\u00e4lt Restbl\u00f6cke. Aber egal wie effektiv sie f\u00fcr tiefe Netzwerke sind, sie st\u00f6ren uns ein wenig. Das Problem ist, dass wir in diesen Schichten keine Faltungen mit unterschiedlichen Indizes l\u00f6schen k\u00f6nnen:<\/p>\n

      <\/p>\n

      \"Die<\/p>\n

      <\/p>\n

      Deshalb heben wir die Schichten hervor, aus denen wir Faltungen ohne Bedenken entfernen k\u00f6nnen:<\/p>\n

      <\/p>\n

      \"Die<\/p>\n

      <\/p>\n

      Jetzt bauen wir einen Arbeitszyklus auf:<\/p>\n

      <\/p>\n

        \n
      1. Aktivierungen exportieren<\/li>\n
      2. Sch\u00e4tzen, wie viel ausgeschnitten werden soll <\/li>\n
      3. Ausschneiden<\/li>\n
      4. Trainieren \u00fcber 10 Epochen mit LR=1e-4 <\/li>\n
      5. Testen <\/li>\n<\/ol>\n

        <\/p>\n

        Es ist hilfreich, Faltungen zu exportieren, um zu bewerten, welchen Teil wir zu einem bestimmten Zeitpunkt entfernen k\u00f6nnen. Beispiele f\u00fcr den Export:<\/p>\n

        <\/p>\n

        \"Die<\/p>\n

        <\/p>\n

        Wir sehen, dass praktisch \u00fcberall 5 % der Faltung eine sehr niedrige L1-Norm aufweisen, sodass wir sie entfernen k\u00f6nnen. Bei jedem Schritt wiederholte sich diese Auslagerung und es wurde bewertet, aus welchen Schichten und wie viel ausgeschnitten werden kann. <\/p>\n

        <\/p>\n

        Der gesamte Prozess wurde in 4 Schritte gegliedert (hier und \u00fcberall beziehen sich die Zahlen auf die RTX 2060 Super):<\/p>\n

        <\/p>\n\n\n\n\n\n\n\n\n\n
        Schritt<\/th>\nmAp75<\/th>\nAnzahl der Parameter, Millionen<\/th>\nNetzwerkgr\u00f6\u00dfe, MB<\/th>\nVon der urspr\u00fcnglichen, %<\/th>\nDurchlaufzeit, ms<\/th>\nBedienung des Zuschneidens<\/th>\n<\/tr>\n<\/thead>\n
        0<\/td>\n0.9656<\/td>\n60<\/td>\n241<\/td>\n100<\/td>\n180<\/td>\n—<\/td>\n<\/tr>\n
        1<\/td>\n0.9622<\/td>\n55<\/td>\n218<\/td>\n91<\/td>\n175<\/td>\n5 % von allem<\/td>\n<\/tr>\n
        2<\/td>\n0.9625<\/td>\n50<\/td>\n197<\/td>\n83<\/td>\n168<\/td>\n5 % von allem<\/td>\n<\/tr>\n
        3<\/td>\n0.9633<\/td>\n39<\/td>\n155<\/td>\n64<\/td>\n155<\/td>\n15 % f\u00fcr Schichten mit 400+ Faltungen<\/td>\n<\/tr>\n
        4<\/td>\n0.9555<\/td>\n31<\/td>\n124<\/td>\n51<\/td>\n146<\/td>\n10 % f\u00fcr Schichten mit 100+ Faltungen<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

        <\/p>\n

        Zu Schritt 2 kam ein positiver Effekt hinzu \u2014 der Batch-Size 4 konnte in den Speicher geladen werden, was den Prozess des Nachtrainierens erheblich beschleunigte.
        \nIm Schritt 4 wurde der Prozess gestoppt, da selbst umfangreiches Nachtrainieren den mAp75 nicht auf die alten Werte hob.
        \nLetztendlich gelang es, die Inferenz um 15%<\/strong>, die Gr\u00f6\u00dfe um 35% <\/strong>zu reduzieren und dabei die Genauigkeit nicht zu verlieren. <\/p>\n

        <\/p>\n

        Automatisierung f\u00fcr einfachere Architekturen<\/h3>\n

        <\/p>\n

        F\u00fcr einfachere Netzwerkarchitekturen (ohne bedingte Additionen, Konkatenierungen und Residualbl\u00f6cke) kann man sich gut auf die Verarbeitung aller Faltungen konzentrieren und den Prozess des Ausschneidens von Faltungen automatisieren.<\/p>\n

        <\/p>\n

        Diese Option habe ich implementiert. hier<\/a><\/noindex>.
        \nEs ist ganz einfach: Sie ben\u00f6tigen lediglich die Verlustfunktion, den Optimierer und die Batch-Generatoren:<\/p>\n

        <\/p>\n

        import pruning\nfrom keras.optimizers import Adam\nfrom keras.utils import Sequence\n\ntrain_batch_generator = BatchGenerator...\nscore_batch_generator = BatchGenerator...\n\nopt = Adam(lr=1e-4)\npruner = pruning.Pruner(\"config.json\", \"categorical_crossentropy\", opt)\n\npruner.prune(train_batch, valid_batch)<\/code><\/pre>\n
        <\/p>\n
        Bei Bedarf k\u00f6nnen die Konfigurationsparameter ge\u00e4ndert werden:<\/p>\n
        <\/p>\n
        {\n    \"input_model_path\": \"model.h5\",\n    \"output_model_path\": \"model_pruned.h5\",\n    \"finetuning_epochs\": 10, # Anzahl der Epochen f\u00fcr das Training zwischen den Pruning-Schritten\n    \"stop_loss\": 0.1, # Verlust zum Stoppen des Prozesses\n    \"pruning_percent_step\": 0.05, # Anteil der Convolutionen, die bei jedem Pruning-Schritt gel\u00f6scht werden\n    \"pruning_standart_deviation_part\": 0.2 # Verschiebung zur Begrenzung des Pruning-Anteils\n}<\/code><\/pre>\n
        <\/p>\n
        \u0414\u043e\u043f\u043e\u043b\u043d\u0438\u0442\u0435\u043b\u044c\u043d\u043e \u0440\u0435\u0430\u043b\u0438\u0437\u043e\u0432\u0430\u043d\u043e \u043e\u0433\u0440\u0430\u043d\u0438\u0447\u0435\u043d\u0438\u0435 \u043d\u0430 \u043e\u0441\u043d\u043e\u0432\u0430\u043d\u0438\u0438 \u0441\u0442\u0430\u043d\u0434\u0430\u0440\u0442\u043d\u043e\u0433\u043e \u043e\u0442\u043a\u043b\u043e\u043d\u0435\u043d\u0438\u044f. \u0426\u0435\u043b\u044c \u2014 \u043e\u0433\u0440\u0430\u043d\u0438\u0447\u0438\u0442\u044c \u0447\u0430\u0441\u0442\u044c \u0443\u0434\u0430\u043b\u044f\u0435\u043c\u044b\u0445, \u0438\u0441\u043a\u043b\u044e\u0447\u0430\u044f \u0441\u0432\u0435\u0440\u0442\u043a\u0438 \u0441 \u0443\u0436\u0435 «\u0434\u043e\u0441\u0442\u0430\u0442\u043e\u0447\u043d\u044b\u043c\u0438» L1-\u043c\u0435\u0440\u0430\u043c\u0438:<\/p>\n
        <\/p>\n
        \"Die<\/p>\n
        <\/p>\n
        So erlauben wir es, nur schwache Convolutionen aus Verteilungen zu entfernen, die der rechten \u00e4hnlich sind, und beeinflussen nicht die Entfernung aus Verteilungen, die der linken \u00e4hnlich sind:<\/p>\n
        <\/p>\n
        \"Die<\/p>\n
        <\/p>\n
        Wenn sich die Verteilung dem Normalverteilung ann\u00e4hert, kann der Koeffizient pruning_standart_deviation_part aus folgendem ausgew\u00e4hlt werden:<\/p>\n
        <\/p>\n
        \"Die
        \nIch empfehle einen Toleranzwert von 2 Sigma. Alternativ kann man sich auch nicht an dieser Besonderheit orientieren und einen Wert < 1,0 beibehalten.<\/p>\n
        <\/p>\n
        Das Ergebnis ist ein Diagramm, das die Netzgr\u00f6\u00dfe, den Verlust und die Laufzeit \u00fcber den gesamten Test hinweg anzeigt, normiert auf 1.0. Zum Beispiel wurde hier die Netzgr\u00f6\u00dfe fast halbiert, ohne Qualit\u00e4tsverlust (eine kleine Faltungsnetzwerk mit 100k Gewichten):<\/p>\n
        <\/p>\n
        \"Die<\/p>\n
        <\/p>\n
        Die Laufgeschwindigkeit unterliegt normalen Schwankungen und hat sich praktisch nicht ver\u00e4ndert. Das hat seine Erkl\u00e4rung:<\/p>\n
        <\/p>\n
          \n
        1. Die Anzahl der Faltungen wechselt von bequemen (32, 64, 128) zu weniger praktischen f\u00fcr Grafikkarten \u2014 27, 51 usw. Ich k\u00f6nnte mich irren, aber wahrscheinlich hat das einen Einfluss.<\/li>\n
        2. Die Architektur ist nicht breit, aber sequenziell. Durch Verkleinerung der Breite ber\u00fchren wir nicht die Tiefe. Dadurch reduzieren wir die Last, \u00e4ndern jedoch nicht die Geschwindigkeit.<\/li>\n<\/ol>\n
          <\/p>\n
          Daher zeigt sich die Verbesserung in der Reduzierung der CUDA-Last w\u00e4hrend des Laufs um 20-30%, jedoch nicht in der Verringerung der Laufzeit.<\/p>\n
          <\/p>\n
          Ergebnisse<\/h3>\n
          <\/p>\n
          Lassen Sie uns reflektieren. Wir haben zwei Varianten des Pruning betrachtet \u2014 f\u00fcr YOLOv3 (wenn man manuell arbeiten muss) und f\u00fcr Netzwerke mit einfacheren Architekturen. Es ist evident, dass man in beiden F\u00e4llen die Netzgr\u00f6\u00dfe reduzieren und die Geschwindigkeit erh\u00f6hen kann, ohne an Genauigkeit zu verlieren. Ergebnisse:<\/p>\n
          <\/p>\n