{"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\/it\/blog\/news\/dzhedajskaya-tehnika-umensheniya-svertochnyh-setej-pruning","title":{"rendered":"Tecnica Jedi per ridurre le reti convoluzionali \u2014 pruning","gt_translate_keys":[{"key":"rendered","format":"text"}]},"content":{"rendered":"

\"Tecnica<\/p>\n

<\/p>\n

Hai di nuovo un compito di rilevamento degli oggetti. La priorit\u00e0 \u00e8 la velocit\u00e0 di funzionamento con una precisione accettabile. Prendi l'architettura YOLOv3 e continua l'addestramento. La precisione (mAp75) deve essere superiore a 0,95. Ma la velocit\u00e0 di elaborazione \u00e8 ancora bassa. Cavolo. <\/p>\n

<\/p>\n

Oggi eviteremo la quantizzazione. Sotto il titolo analizzeremo Potatura del Modello<\/strong> \u2014 rimozione delle parti ridondanti della rete per accelerare l'inferenza senza perdita di precisione. In modo chiaro \u2014 da dove, quanto e come \u00e8 possibile rimuovere. Vedremo come farlo manualmente e dove \u00e8 possibile automatizzare. Alla fine \u2014 un repository su keras.<\/p>\n

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

Introduzione<\/h3>\n

<\/p>\n

Nel mio precedente lavoro, a Macroscop di Perm, ho sviluppato un'abitudine \u2014 controllare sempre il tempo di esecuzione degli algoritmi. E il tempo di elaborazione delle reti va sempre verificato attraverso un filtro di adeguatezza. Di solito, le soluzioni all'avanguardia non superano questo filtro, e questo mi ha portato alla Potatura. <\/p>\n

<\/p>\n

La Potatura \u00e8 un tema vecchio, di cui si \u00e8 parlato nelle lezioni di Stanford<\/a><\/noindex> nel 2017. L'idea principale \u00e8 ridurre la dimensione della rete addestrata senza perdita di precisione rimuovendo diversi nodi. Sembra interessante, ma raramente sento parlare del suo utilizzo. Probabilmente mancano implementazioni, non ci sono articoli in lingua russa, o semplicemente tutti considerano la potatura un segreto e tacciono.
\nMa andiamo a esaminare<\/p>\n

<\/p>\n

Uno sguardo alla biologia<\/h3>\n

<\/p>\n

Mi piace quando nel Deep Learning entrano idee provenienti dalla biologia. A loro, come all'evoluzione, si pu\u00f2 dare fiducia (sapevi che la ReLU \u00e8 molto simile a una funzione di attivazione dei neuroni nel cervello<\/a><\/noindex>?) <\/p>\n

<\/p>\n

Il processo di Potatura del Modello \u00e8 anche vicino alla biologia. La reazione della rete pu\u00f2 essere paragonata alla plasticit\u00e0 del cervello. Ci sono alcuni esempi interessanti nel libro di Norman Doidge<\/a><\/noindex>:<\/p>\n

<\/p>\n

    \n
  1. Il cervello di una donna che aveva solo met\u00e0 da quando \u00e8 nata ha riprogrammato se stesso per svolgere le funzioni della met\u00e0 mancante<\/li>\n
  2. Un ragazzo si \u00e8 sparato a una parte del cervello responsabile della vista. Col tempo, altre parti del cervello hanno assunto queste funzioni. (non proviamo a ripetere)<\/li>\n<\/ol>\n

    <\/p>\n

    Cos\u00ec anche dal tuo modello puoi rimuovere alcune convoluzioni deboli. In casi estremi, le convoluzioni rimanenti possono aiutare a sostituire quelle rimosse. <\/p>\n

    <\/p>\n

    Preferisci il Transfer Learning o inizi da zero?<\/h3>\n

    <\/p>\n

    Opzione numero uno.<\/strong> Stai utilizzando il Transfer Learning su Yolov3. Retina, Mask-RCNN o U-Net. Ma nella maggior parte dei casi non \u00e8 necessario riconoscere 80 classi di oggetti, come nel COCO. Nella mia pratica, ci si limita a 1-2 classi. Si pu\u00f2 supporre che l'architettura per 80 classi sia eccessiva. Si fa pensare che sia necessario ridurre l'architettura. Inoltre, vorremmo farlo senza perdere i pesi pre-addestrati esistenti.<\/p>\n

    <\/p>\n

    Opzione numero due.<\/strong> Forse hai molti dati e risorse di calcolo o hai semplicemente bisogno di un'architettura super personalizzata. Non importa. Ma stai addestrando la rete da zero. L'ordine abituale \u00e8 osservare la struttura dei dati, scegliere un'architettura ECCESSIVA in termini di potenza e applicare il dropout per evitare il sovraccarico. Ho visto dropout a 0.6, Karl. <\/p>\n

    <\/p>\n

    In entrambi i casi, \u00e8 possibile ridurre la rete. Ci siamo motivati. Ora andiamo a capire cos'\u00e8 il pruning.<\/p>\n

    <\/p>\n

    Algoritmo generale<\/h3>\n

    <\/p>\n

    Abbiamo deciso che possiamo rimuovere le convoluzioni. Questo sembra piuttosto semplice:<\/p>\n

    <\/p>\n

    \"Tecnica<\/p>\n

    <\/p>\n

    Rimuovere qualsiasi convoluzione \u00e8 uno stress per la rete, che di solito porta anche a un certo aumento dell'errore. Da un lato, questo aumento dell'errore \u00e8 un indicatore di quanto correttamente stiamo rimuovendo le convoluzioni (ad esempio, un grande aumento indica che stiamo facendo qualcosa di sbagliato). Ma un piccolo aumento \u00e8 del tutto accettabile e spesso pu\u00f2 essere corretto con un successivo leggero riaddestramento con un LR ridotto. Aggiungiamo un passaggio di riaddestramento:<\/p>\n

    <\/p>\n

    \"Tecnica<\/p>\n

    <\/p>\n

    Ora dobbiamo capire quando vogliamo fermare il nostro ciclo LearningPruning. Ci possono essere varianti esotiche, quando dobbiamo ridurre la rete a una certa dimensione e velocit\u00e0 di esecuzione (ad esempio, per dispositivi mobili). Tuttavia, la variante pi\u00f9 comune \u00e8 quella di continuare il ciclo finch\u00e9 l'errore non supera un certo limite. Aggiungiamo una condizione:<\/p>\n

    <\/p>\n

    \"Tecnica<\/p>\n

    <\/p>\n

    Quindi, l'algoritmo diventa chiaro. Rimane da capire come determinare le convoluzioni da rimuovere.<\/p>\n

    <\/p>\n

    Ricerca delle convoluzioni da rimuovere<\/h3>\n

    <\/p>\n

    Dobbiamo rimuovere alcune compressioni. Rompere a tutta forza e \"eliminare\" qualsiasi cosa \u00e8 un'idea sbagliata, anche se funzioner\u00e0. Ma se si \u00e8 in grado di pensare, si pu\u00f2 considerare di identificare e rimuovere le compressioni \"deboli\". Ci sono diverse opzioni:<\/p>\n

    <\/p>\n

      \n
    1. La misura L1 minima o low_magnitude_pruning<\/a><\/noindex>. L'idea \u00e8 che le convoluzioni con valori di peso piccoli contribuiscono poco alla decisione finale. <\/li>\n
    2. La misura L1 pi\u00f9 piccola tenendo conto della media e della deviazione standard. Completiamo con la valutazione della natura della distribuzione.<\/li>\n
    3. Mascheramento delle convoluzioni e esclusione delle meno influenti sulla precisione finale<\/a><\/noindex>. Una definizione pi\u00f9 precisa delle convoluzioni insignificanti, ma piuttosto costosa in termini di tempo e risorse. <\/li>\n
    4. Altri <\/li>\n<\/ol>\n

      <\/p>\n

      Ognuno delle opzioni ha diritto di esistere e le proprie peculiarit\u00e0 di implementazione. Qui considereremo l'opzione con la misura L1 pi\u00f9 piccola<\/p>\n

      <\/p>\n

      Processo manuale per YOLOv3<\/h3>\n

      <\/p>\n

      Nell'architettura originale ci sono blocchi residuali. Ma per quanto possano essere fantastici per le reti profonde, ci daranno un po' fastidio. Il problema \u00e8 che non si possono rimuovere le convoluzioni con indici diversi in questi strati:<\/p>\n

      <\/p>\n

      \"Tecnica<\/p>\n

      <\/p>\n

      Quindi evidenzieremo gli strati da cui possiamo rimuovere liberamente le convoluzioni:<\/p>\n

      <\/p>\n

      \"Tecnica<\/p>\n

      <\/p>\n

      Ora costruiremo un ciclo di lavoro:<\/p>\n

      <\/p>\n

        \n
      1. Esportiamo le attivazioni<\/li>\n
      2. Calcoliamo quanto tagliare <\/li>\n
      3. Tagliamo<\/li>\n
      4. Alleniamo per 10 epoche con LR=1e-4 <\/li>\n
      5. Testiamo <\/li>\n<\/ol>\n

        <\/p>\n

        Esportare le convoluzioni \u00e8 utile per valutare quale parte possiamo rimuovere in un certo passaggio. Esempi di esportazione:<\/p>\n

        <\/p>\n

        \"Tecnica<\/p>\n

        <\/p>\n

        Vediamo che praticamente ovunque il 5% delle convoluzioni ha una L1 norm molto bassa e possiamo eliminarle. In ogni passaggio tale esportazione \u00e8 stata ripetuta e sono state valutate da quali strati e quanto si poteva tagliare. <\/p>\n

        <\/p>\n

        L'intero processo si \u00e8 svolto in 4 passaggi (qui e ovunque i numeri sono per RTX 2060 Super):<\/p>\n

        <\/p>\n\n\n\n\n\n\n\n\n\n
        Passaggio<\/th>\nmAp75<\/th>\nNumero di parametri, mln<\/th>\nDimensione della rete, mb<\/th>\nDall'originale, %<\/th>\nTempo di esecuzione, ms<\/th>\nCondizione di potatura<\/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% di tutti<\/td>\n<\/tr>\n
        2<\/td>\n0.9625<\/td>\n50<\/td>\n197<\/td>\n83<\/td>\n168<\/td>\n5% di tutti<\/td>\n<\/tr>\n
        3<\/td>\n0.9633<\/td>\n39<\/td>\n155<\/td>\n64<\/td>\n155<\/td>\n15% per strati con 400+ convoluzioni<\/td>\n<\/tr>\n
        4<\/td>\n0.9555<\/td>\n31<\/td>\n124<\/td>\n51<\/td>\n146<\/td>\n10% per strati con 100+ convoluzioni<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

        <\/p>\n

        Al secondo passaggio \u00e8 emerso un effetto positivo \u2014 \u00e8 riuscito a contenere un batch size di 4 in memoria, accelerando notevolmente il processo di riaddestramento.
        \nNel quarto passaggio il processo \u00e8 stato interrotto, poich\u00e9 anche un lungo riaddestramento non ha sollevato mAp75 ai vecchi valori.
        \nIn definitiva, siamo riusciti ad accelerare l'inferenza di 15%<\/strong>, ridurre la dimensione di 35% <\/strong>e non perdere in precisione. <\/p>\n

        <\/p>\n

        Automazione per architetture pi\u00f9 semplici<\/h3>\n

        <\/p>\n

        Per architetture di rete pi\u00f9 semplici (senza blocchi addizionali, concatenati e residuali) \u00e8 possibile orientarsi verso l'elaborazione di tutti gli strati convoluzionali e automatizzare il processo di rimozione delle convoluzioni.<\/p>\n

        <\/p>\n

        Ho implementato tale opzione qui<\/a><\/noindex>.
        \n\u00c8 tutto molto semplice: hai solo bisogno della funzione di perdita, dell'ottimizzatore e dei generatori di batch:<\/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
        Se necessario, puoi modificare i parametri della configurazione:<\/p>\n
        <\/p>\n
        {\n    \"input_model_path\": \"model.h5\",\n    \"output_model_path\": \"model_pruned.h5\",\n    \"finetuning_epochs\": 10, # il numero di epoche per l'addestramento tra i passaggi di potatura\n    \"stop_loss\": 0.1, # perdita per fermare il processo\n    \"pruning_percent_step\": 0.05, # parte delle convoluzioni da eliminare ad ogni passaggio di potatura\n    \"pruning_standart_deviation_part\": 0.2 # scostamento per limitare la parte di potatura\n}<\/code><\/pre>\n
        <\/p>\n
        In aggiunta, \u00e8 stata implementata una restrizione basata sulla deviazione standard. L'obiettivo \u00e8 limitare la parte rimossa, escludendo le compressioni con gi\u00e0 \"sufficienti\" misure L1:<\/p>\n
        <\/p>\n
        \"Tecnica<\/p>\n
        <\/p>\n
        In questo modo, permettiamo di rimuovere solo le convoluzioni deboli da distribuzioni simili a quella destra e di non influire sulla rimozione da distribuzioni simili a quella sinistra:<\/p>\n
        <\/p>\n
        \"Tecnica<\/p>\n
        <\/p>\n
        Con l'avvicinarsi della distribuzione a una normale, il coefficiente pruning_standart_deviation_part pu\u00f2 essere scelto da:<\/p>\n
        <\/p>\n
        \"Tecnica
        \nRaccomando un'affidabilit\u00e0 di 2 sigma. Oppure non fare riferimento a questa caratteristica, lasciando il valore < 1.0.<\/p>\n
        <\/p>\n
        Il risultato finale \u00e8 un grafico delle dimensioni della rete, della perdita e del tempo di esecuzione della rete su tutto il test, normalizzato a 1.0. Ad esempio, qui la dimensione della rete \u00e8 stata ridotta quasi della met\u00e0 senza perdita di qualit\u00e0 (una piccola rete convoluzionale con 100k pesi):<\/p>\n
        <\/p>\n
        \"Tecnica<\/p>\n
        <\/p>\n
        La velocit\u00e0 di esecuzione \u00e8 soggetta a fluttuazioni normali e praticamente non \u00e8 cambiata. Questo ha una spiegazione:<\/p>\n
        <\/p>\n
          \n
        1. Il numero di convoluzioni cambia da comodi (32, 64, 128) a meno comodi per le schede grafiche \u2014 27, 51 e cos\u00ec via. Potrei sbagliarmi, ma probabilmente questo influisce.<\/li>\n
        2. L'architettura non \u00e8 ampia, ma sequenziale. Riducendo la larghezza, non tocchiamo la profondit\u00e0. Questo riduce il carico, ma non cambia la velocit\u00e0.<\/li>\n<\/ol>\n
          <\/p>\n
          Pertanto, il miglioramento si \u00e8 tradotto in una riduzione del carico CUDA durante l'esecuzione del 20-30%, ma non in una riduzione dei tempi di esecuzione.<\/p>\n
          <\/p>\n
          Conclusioni<\/h3>\n
          <\/p>\n
          Riflettiamo. Abbiamo considerato 2 opzioni di potatura \u2014 per YOLOv3 (quando \u00e8 necessario lavorare manualmente) e per reti con architetture pi\u00f9 semplici. \u00c8 evidente che in entrambi i casi si pu\u00f2 ottenere una riduzione della dimensione della rete e un'accelerazione senza perdita di precisione. Risultati:<\/p>\n
          <\/p>\n