In de vorige delen (Deel 1, Deel 2, Deel 3, Deel 4), hebben we besproken waarom efficiëntie belangrijk is voor deep learning-modellen om hoogwaardige modellen te bereiken die pareto-optimaal zijn, evenals de aandachtsgebieden voor efficiëntie in Deep Learning. We hebben ook vier van de aandachtsgebieden behandeld (compressietechnieken, leertechnieken, automatisering en efficiënte architecturen). Laten we deze serie afsluiten met het laatste deel over de fundamentele infrastructuur die essentieel is voor het trainen en implementeren van krachtige modellen.

Even terzijde, u bent ook van harte welkom om onze enquêtedocument over efficiëntie bij diep leren, waarin dit onderwerp nader wordt behandeld.

Infrastructuur

Om inferentie efficiënt te kunnen trainen en uitvoeren, moet er een robuuste basis voor software- en hardware-infrastructuur zijn. In deze paragraaf gaan we op beide aspecten in.

Een mentaal model van de software- en hardware-infrastructuur en hoe ze met elkaar omgaan.

Tensorflow-ecosysteem:

Tensorflow (TF) [1] is een populair machine learning-framework dat door veel grote ondernemingen in productie is gebruikt. Het heeft een van de meest uitgebreide softwareondersteuning voor modelefficiëntie.

Tensorflow Lite voor gebruiksscenario's op het apparaat: Tensorflow Lite (TFLite) [2] is een verzameling tools en bibliotheken die zijn ontworpen voor inferentie in omgevingen met weinig middelen, zoals edge-apparaten. Op een hoog niveau kunnen we de TFLite opsplitsen in twee kerndelen:

• Interpreter en Op Kernels: TFLite biedt een interpreter voor het uitvoeren van gespecialiseerde TFLite-modellen, samen met implementaties van algemene neurale netwerkbewerkingen (Fully Connected, Convolution, Max Pooling, ReLu, Softmax, etc. elk als een Op). De interpreter en bewerkingen zijn voornamelijk geoptimaliseerd voor gevolgtrekking op ARM-gebaseerde processors vanaf het moment van schrijven van dit bericht. Ze kunnen ook gebruikmaken van smartphone-DSP's zoals Qualcomm's Hexagon [3] voor snellere uitvoering.
• Converter: Dit is een hulpmiddel voor het converteren van het gegeven TF-model naar een enkel bestand voor gevolgtrekking door de interpreter. Afgezien van de conversie zelf, verwerkt het veel interne details, zoals het gereedmaken van een grafiek voor gekwantiseerde inferentie (zoals vermeld in eerdere berichten), het fuseren van bewerkingen, het toevoegen van andere metadata aan het model, enz.

Andere hulpmiddelen voor inferentie op het apparaat: Evenzo zijn er ook tools voor inferentie op andere platforms. TF Micro [4] heeft bijvoorbeeld een afgeslankte interpreter en een kleinere set van ops voor inferentie op microcontrollers met een zeer lage bron, zoals DSP's. TensorflowJS (TF.JS) [5] is een bibliotheek binnen het TF-ecosysteem die kan worden gebruikt om neurale netwerken binnen de browser of met behulp van Node.js te trainen en uit te voeren. Deze modellen kunnen ook worden versneld via GPU's via de WebGL-interface [6]. Het ondersteunt zowel het importeren van modellen die getraind zijn in TF als het creëren van nieuwe modellen vanuit het niets in TF.JS. Er is ook de TF Model Optimization Toolkit [7], die het toevoegen van kwantisering, sparsiteit, gewichtsclustering enz. in een modelgrafiek biedt.

XLA voor server-side acceleratie: XLA (Accelerated Linear Algebra) [8] is een grafiekcompiler die lineaire algebraberekeningen in een model kan optimaliseren door nieuwe implementaties voor bewerkingen (kernels) te genereren die zijn aangepast voor de grafiek. Bepaalde operaties die kunnen worden samengevoegd, worden bijvoorbeeld gecombineerd in een enkele samengestelde operatie. Dit voorkomt dat meerdere kostbare schrijfbewerkingen naar RAM moeten worden uitgevoerd wanneer de operanden direct kunnen worden bediend terwijl ze zich nog in de cache bevinden. Kanwar et al. [9] rapporteer een 7× toename van de trainingsdoorvoer en een 5× toename van de maximale batchgrootte die kan worden gebruikt voor BERT-training met behulp van XLA. Hierdoor kan een BERT-model worden getraind voor $ 32 op Google Cloud.

PyTorch-ecosysteem: 

PyTorch [10] is een ander populair machine-learningplatform dat actief wordt gebruikt door zowel de academische wereld als de industrie, en het kan worden vergeleken met Tensorflow in termen van bruikbaarheid en functies.

Gebruikssituaties op het apparaat: PyTorch heeft ook een lichtgewicht interpreter die het mogelijk maakt om PyTorch-modellen op mobiel [11] uit te voeren, met native runtimes voor Android en iOS (analoog aan TFLite-interpreter). PyTorch biedt ook kwantisering na de training [12] en andere grafische optimalisatiestappen, zoals constant vouwen, het samenvoegen van bepaalde bewerkingen en het als laatste (NHWC) formaat van de kanalen voor het optimaliseren van convolutionele lagen.

Algemene modeloptimalisatie: PyTorch biedt ook de Just-in-Time (JIT)-compilatiefaciliteit [13] voor het genereren van een serialiseerbare tussenweergave van het model uit de code in TorchScript [14], een subset van Python en voegt functies toe zoals typecontroles. Het maakt het mogelijk een brug te slaan tussen de flexibele PyTorch-code voor onderzoek en ontwikkeling naar een representatie die kan worden ingezet voor inferentie in productie. Het is de primaire manier waarop PyTorch-modellen worden uitgevoerd op mobiele apparaten.

De alternatieven voor XLA in de PyTorch-wereld lijken de Glow [15] en TensorComprehension [16] compilers te zijn. Ze helpen bij het genereren van de lagere intermediaire representatie (IR) die is afgeleid van de IR op een hoger niveau, zoals TorchScript.

PyTorch biedt ook een modelafstemmingsgids [17] met details over verschillende opties die ML-beoefenaars tot hun beschikking hebben. Enkele van de kernideeën daarin zijn:

• Fusie van puntsgewijze bewerkingen (optellen, aftrekken, vermenigvuldigen, delen, etc.) met behulp van PyTorch JIT.
• Door buffercontrolepunten in te schakelen, kunnen de uitvoer van alleen bepaalde lagen in het geheugen worden bewaard en de rest worden berekend tijdens de achterwaartse doorgang. Dit helpt met name bij goedkoop te berekenen lagen met grote outputs zoals activeringen.
• Apparaatspecifieke optimalisaties inschakelen, zoals de cuDNN-bibliotheek en Mixed Precision Training met NVIDIA GPU's (uitgelegd in de GPU-subsectie).
• Train met Distributed Data Parallel Training, wat geschikt is wanneer er een grote hoeveelheid gegevens is en er meerdere GPU's beschikbaar zijn voor training.

Voor hardware geoptimaliseerde bibliotheken:

We kunnen de efficiëntie verder verhogen door onze softwarestack te optimaliseren voor de hardware waarop de neurale netwerken draaien. De Cortex-processorfamilie van ARM ondersteunt bijvoorbeeld SIMD-instructies (Single-Instruction Multiple Data) die vectorisering van de bewerking (werken met batches gegevens) mogelijk maken met behulp van de Neon-instructieset. QNNPACK [18] en XNNPACK [19] bibliotheken zijn geoptimaliseerd voor ARM Neon voor mobiele en embedded apparaten en voor x86 SSE2, AVX-architecturen, enz. De eerste wordt gebruikt voor gekwantiseerde inferentiemodus voor PyTorch, en de laatste ondersteunt 32-bits zwevende- puntmodellen en 16-bits drijvende komma voor TFLite. Evenzo zijn er andere bibliotheken op laag niveau, zoals Accelerate voor iOS [20] en NNAPI voor Android [21] die proberen de beslissing over versnelling op hardwareniveau te abstraheren van hogere ML-frameworks.

Hardware 

GPU: Graphics Processing Units (GPU's), hoewel oorspronkelijk ontworpen voor het versnellen van computergraphics, begonnen te worden gebruikt voor algemene doeleinden met de beschikbaarheid van de CUDA-bibliotheek [22] in 2007. AlexNet [23] won de ImageNet-competitie in 2012 het gebruik van GPU's voor deep learning-modellen gestandaardiseerd. Sindsdien heeft Nvidia verschillende iteraties van zijn GPU-microarchitecturen uitgebracht met een toenemende focus op deep learning-prestaties. Het heeft ook Tensor Cores [24] geïntroduceerd, dit zijn speciale uitvoeringseenheden en ondersteunen training en inferentie in een reeks precisies (fp32, TensorFloat32, fp16, bfloat16, int8, int4).

Reduced Precision Multiply-and-Accumulate (MAC)-bewerking: B x C is een dure bewerking en wordt daarom met verminderde precisie uitgevoerd.

Tensor Cores optimaliseren de standaard Multiply-and-Accumulate (MAC)-bewerking, A = (B × C) + D. Waarbij B en C een verminderde precisie hebben (fp16, bfloat16, TensorFloat32), terwijl A en D zich in fp32 bevinden . NVIDIA meldt tussen 1× tot 15× trainingssnelheid met deze verminderde precisie MAC-bewerkingen, afhankelijk van de modelarchitectuur en de gekozen GPU [25]. Tensor Cores in NVidia's nieuwste Ampere-architectuur GPU's ondersteunen ook snellere inferentie met sparsity (met name gestructureerde sparsity in de verhouding 2:4, waarbij 2 elementen uit een blok van 4 elementen schaars zijn). Ze laten een snelheidstoename tot 1.5× zien in de inferentietijd en tot 1.8× versnelling in afzonderlijke lagen. Afgezien hiervan biedt NVidia ook de cuDNN-bibliotheek [29] die geoptimaliseerde versies van standaard neurale netwerkbewerkingen bevat, zoals volledig verbonden, convolutie, batchnorm, activering, enz.

Gegevenstypen die worden gebruikt tijdens training en inferentie over GPU's en TPU's. bfloat16 is afkomstig van TPU's en Tensor Float 32 wordt alleen ondersteund op NVidia GPU's.

TPU: TPU's zijn eigen applicatiespecifieke geïntegreerde circuits (ASIC's) die Google heeft ontworpen om deep learning-applicaties te versnellen met Tensorflow en nauwkeurig afgesteld voor parallellisering en versnelling van lineaire algebra-bewerkingen. TPU-architecturen ondersteunen zowel training als inferentie met TPU's en zijn beschikbaar voor het grote publiek via hun Google Cloud-service. De kernarchitectuur van de TPU-chips maakt gebruik van het Systolic Array-ontwerp [26], waarbij een grote berekening wordt gesplitst over een mesh-achtige topologie, waarbij elke cel een gedeeltelijk resultaat berekent en dit doorgeeft aan de volgende cel in de volgorde, elke klok -stap (op een ritmische manier analoog aan het systolische hartritme), zonder dat tussentijdse resultaten in het geheugen hoeven te worden opgeslagen.

Elke TPU-chip heeft twee Tensor Cores (niet te verwarren met NVidia's Tensor Cores), die elk een netwerk van systolische arrays hebben. Er zijn 4 onderling verbonden TPU-chips op een enkel TPU-bord. Om training en inferentie verder op te schalen, kan een groter aantal TPU-kaarten in een mesh-topologie worden aangesloten om een ​​'pod' te vormen. Volgens openbaar vrijgegeven cijfers kan elke TPU-chip (v3) 420 teraflops bereiken en een TPU-pod 100+ petaflops [27]. TPU's zijn binnen Google gebruikt voor toepassingen zoals trainingsmodellen voor Google Zoeken, BERT-modellen voor algemene doeleinden, toepassingen zoals DeepMind's wereldberoemde AlphaGo- en AlphaZero-modellen en vele andere onderzoekstoepassingen [28]. Net als de GPU's ondersteunen TPU's het bfloat16-gegevenstype, dat een alternatief met verminderde precisie is voor training met 32-bits precisie met volledige drijvende komma. XLA-ondersteuning maakt het mogelijk om transparant over te schakelen naar bfloat16 zonder modelwijzigingen.

Een illustratie van een basale systolische array-cel, en een 4×4 matrixvermenigvuldiging met behulp van een netwerk van systolische array-cellen.

Geschatte grootte van de EdgeTPU, Coral en het ontwikkelbord. (Met dank aan: Bhuwan Chopra)

EdgeTPU: EdgeTPU is ook een aangepaste ASIC-chip die is ontworpen door Google. Net als de TPU is het gespecialiseerd voor het versnellen van lineaire algebra-bewerkingen, maar alleen voor inferentie en met een veel lager rekenbudget op edge-apparaten. Het is verder beperkt tot slechts een subset van bewerkingen en werkt alleen met int8 gekwantiseerde Tensorflow Lite-modellen. De EdgeTPU-chip zelf is kleiner dan een Amerikaanse cent, waardoor hij geschikt is voor implementatie in vele soorten IoT-apparaten. Het is geïmplementeerd in Raspberry-Pi-achtige ontwikkelborden, in Pixel 4-smartphones als Pixel Neural Core en kan ook onafhankelijk op een PCB worden gesoldeerd.

Jetson Nano-module. (bron)

Jetson: Jetson is een familie van versnellers van Nvidia om deep learning-toepassingen voor embedded en IoT-apparaten mogelijk te maken. Het omvat de Nano, een low-powered "system on a module" (SoM) ontworpen voor lichtgewicht implementaties, evenals de krachtigere Xavier- en TX-varianten, die zijn gebaseerd op de NVidia Volta- en Pascal GPU-architecturen. De Nano is geschikt voor toepassingen zoals domotica en de rest voor meer rekenintensieve toepassingen zoals industriële robotica.

Samengevat

In deze serie zijn we begonnen met het demonstreren van de snelle groei van modellen in de Deep Learning-ruimte en het motiveren van de behoefte aan efficiëntie en prestaties terwijl we ze blijven opschalen. We volgden dat op door een mentaal model te leggen voor de lezers om het enorme landschap van tools en technieken die ze kunnen gebruiken te begrijpen. Vervolgens zijn we dieper ingegaan op elk van de aandachtsgebieden om gedetailleerde voorbeelden te geven en het werk dat tot nu toe in de industrie en de academische wereld is gedaan, verder te illustreren. We hopen dat deze reeks blogposts hopelijk concrete en bruikbare tips zal geven, evenals afwegingen voor de lezer om over na te denken bij het optimaliseren van een model voor training en implementatie. We nodigen de lezers uit om onze meer gedetailleerde onderzoekspaper over modeloptimalisatie en efficiëntie voor verdere inzichten.

Referenties

[1] Martín Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, et al. 2016. Tensorflow: een systeem voor grootschalige machine learning. In het 12e {USENIX} symposium over het ontwerp en de implementatie van besturingssystemen ({OSDI} 16). 265-283.

[2] Tensorflow-auteurs. 2021. TensorFlow Lite | ML voor mobiele en Edge-apparaten. https://www.tensorflow.org/lite [Online; geraadpleegd op 3 juni 2021].

[3] XNNPACK-auteurs. 2021. XNNPACK-backend voor TensorFlow Lite. https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/delegates/xnnpack/README.md/#sparse-inference.

[4] Pete Warden en Daniel Situnayake. 2019. Tinyml: Machine learning met tensorflow lite op arduino en ultra-low-power microcontrollers. "O'Reilly Media, Inc.".

[5] Tensorflow-JS: https://www.tensorflow.org/js

[6] WebGL: https://en.wikipedia.org/wiki/WebGL

[7] TensorFlow. 2019. TensorFlow Model Optimization Toolkit — Kwantisering van integers na de training. Gemiddeld (november 2019). https://medium.com/tensorflow/tensorflow-model-optimization-toolkit-post-training-integer-quantizationb4964a1ea9ba

[8] Tensorflow-auteurs. 2021. XLA: Compiler optimaliseren voor machine learning | TensorFlow. https://www.tensorflow. org/xla.

[9] Pankaj Kanwar, Peter Brandt en Zongwei Zhou. 2021. TensorFlow 2 MLPerf-inzendingen demonstreren de beste prestaties in hun klasse op Google Cloud. https://blog.tensorflow.org/2020/07/tensorflow-2-mlperf-submissions.html.

[10] Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. 2019. Pytorch: een imperatieve stijl, krachtige deep learning-bibliotheek. arXiv voordruk arXiv:1912.01703 (2019).

[11] PyTorch-auteurs. 2021. PyTorch Mobiel. https://pytorch.org/mobile/home.

[12] PyTorch-auteurs. 2021. Kwantiseringsrecept — PyTorch-zelfstudies 1.8.1+cu102 documentatie. https://pytorch.org/tutorials/recipes/quantization.html.

[13] PyTorch-auteurs. 2021. torch.jit.script — PyTorch 1.8.1-documentatie. https://pytorch.org/docs/stable/generated/ torch.jit.script.html

[14] PyTorch-auteurs. 2021. torch.jit.script — PyTorch 1.8.1-documentatie. https://pytorch.org/docs/stable/generated/ torch.jit.script.html

[15] Nadav Rotem, Jordan Fix, Saleem Abdulrasool, Garret Catron, Summer Deng, Roman Dzhabarov, Nick Gibson, James Hegeman, Meghan Lele, Roman Levenstein, et al. 2018. Glow: Graph-verlagende compilertechnieken voor neurale netwerken. arXiv voordruk arXiv:1805.00907 (2018).

[16] Nicolas Vasilache, Oleksandr Zinenko, Theodoros Theodoridis, Priya Goyal, Zachary DeVito, William S Moses, Sven Verdoolaege, Andrew Adams en Albert Cohen. 2018. Tensorbegrippen: framework-agnostische high-performance machine learning-abstracties. arXiv voordruk arXiv:1802.04730 (2018).

[17] PyTorch-auteurs. 2021. Performance Tuning Guide - PyTorch-zelfstudies 1.8.1 + cu102-documentatie. https: //pytorch.org/tutorials/recipes/recipes/tuning_guide.html

[18] Marat Dukhan, Yiming Wu Wu en Hao Lu. 2020. QNNPACK: Open source bibliotheek voor geoptimaliseerd mobiel deep learning – Facebook Engineering. https://engineering.fb.com/2018/10/29/ml-applications/qnnpack

[19] XNNPACK-auteurs. 2021. XNNPAKKET. https://github.com/google/XNNPACK

[20] Apple-auteurs. 2021. Versnellen | Documentatie voor Apple-ontwikkelaars. https://developer.apple.com/documentation/accelereren

[21] Android-ontwikkelaars. 2021. Neural Networks API | Android NDK | Android-ontwikkelaars. https://developer.android. com/ndk/guides/neuralnetworks.

[22] Medewerkers aan Wikimedia-projecten. 2021. CUDA – Wikipedia. https://en.wikipedia.org/w/index.php?title=CUDA& oldid=1025500257.

[23] Alex Krizhevsky, Ilya Sutskever en Geoffrey E Hinton. 2012. Imagenet-classificatie met diepe convolutionele neurale netwerken. Vooruitgang in neurale informatieverwerkingssystemen 25 (2012), 1097-1105.

[24] NVIDIA. 2020. Inside Volta: 's werelds meest geavanceerde datacenter-GPU | NVIDIA-ontwikkelaarsblog. https: //developer.nvidia.com/blog/inside-volta.

[25] Dusan Stosic. 2020. Neurale netwerken trainen met tensorkernen - Dusan Stosic, NVIDIA. https://www.youtube. com/watch?v=jF4-_ZK_tyc

[26] HT Kung en CE Leiserson. 1980. Inleiding tot VLSI-systemen. Mead, C.A_, en Conway, L., (Eds), Addison-Wesley, Reading, MA (1980), 271-292.

[27] Kaz Sato. 2021. Wat maakt TPU's afgestemd op deep learning? | Google Cloud-blog. https://cloud.google.com/ blog/products/ai-machine-learning/what-makes-tpus-fine-tuned-for-deep-learning

Zie ook:

• NVIDIA GPU-versnelde bibliotheken gebruiken
• Aan de slag met gedistribueerde machine learning met PyTorch en Ray
• De beste frameworks en extensies voor machine learning voor TensorFlow