WO2020240113A1 - Procede d'implementation d'un accelerateur materiel d'un reseau de neurones - Google Patents

Procede d'implementation d'un accelerateur materiel d'un reseau de neurones Download PDF

Info

Publication number
WO2020240113A1
WO2020240113A1 PCT/FR2020/050822 FR2020050822W WO2020240113A1 WO 2020240113 A1 WO2020240113 A1 WO 2020240113A1 FR 2020050822 W FR2020050822 W FR 2020050822W WO 2020240113 A1 WO2020240113 A1 WO 2020240113A1
Authority
WO
WIPO (PCT)
Prior art keywords
neural network
hardware accelerator
implementing
fpga
programmable logic
Prior art date
Application number
PCT/FR2020/050822
Other languages
English (en)
Inventor
Alban BOURGE
Meven MOGNOL
Emrick SINITAMBIRIVOUTIN
Original Assignee
Bull Sas
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Bull Sas filed Critical Bull Sas
Priority to EP20737247.5A priority Critical patent/EP3977363A1/fr
Priority to US17/614,081 priority patent/US20230004775A1/en
Publication of WO2020240113A1 publication Critical patent/WO2020240113A1/fr

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
    • G06N3/00—Computing arrangements based on biological models
    • G06N3/02—Neural networks
    • G06N3/10—Interfaces, programming languages or software development kits, e.g. for simulating neural networks
    • G06N3/105—Shells for specifying net layout
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
    • G06N3/00—Computing arrangements based on biological models
    • G06N3/02—Neural networks
    • G06N3/04—Architecture, e.g. interconnection topology
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
    • G06N3/00—Computing arrangements based on biological models
    • G06N3/02—Neural networks
    • G06N3/04—Architecture, e.g. interconnection topology
    • G06N3/045—Combinations of networks
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
    • G06N3/00—Computing arrangements based on biological models
    • G06N3/02—Neural networks
    • G06N3/06—Physical realisation, i.e. hardware implementation of neural networks, neurons or parts of neurons
    • G06N3/063—Physical realisation, i.e. hardware implementation of neural networks, neurons or parts of neurons using electronic means
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
    • G06N3/00—Computing arrangements based on biological models
    • G06N3/02—Neural networks
    • G06N3/08—Learning methods

Definitions

  • the invention relates to the field of methods of implementing a hardware accelerator of a neural network, as well as the field of electronic cards implementing a hardware accelerator of a neural network.
  • a method of implementing a hardware accelerator of a neural network is a method of implementing a hardware accelerator of a neural network algorithm.
  • the methods of implementing a hardware accelerator of a neural network make it possible to create and train specific neural networks on a reconfigurable hardware target (FPGA for “Field-Programmable Gâte Array” in English) and then to them. use on datasets.
  • FPGA Field-Programmable Gâte Array
  • the invention is also interested in carrying out, for these methods of implementing a hardware accelerator of a neural network, on the one hand a simplification of the use for a non-expert user for the software aspect and on the other hand a certain automation in the way of using a series of tools which are quite complex to handle and requiring a relatively high level of expertise.
  • FPGA Field Programmable Gâte Array
  • the aim of the present invention is to provide a method for implementing a hardware accelerator of a neural network which at least partially overcomes the aforementioned drawbacks.
  • this implementation of the prior art remains very general, that is to say that it keeps a matrix of calculation elements as an acceleration core which must regularly, with each new layer of the neural network or with each new operation performed by the neural network, to be reloaded and even reprogrammed with parameters stored in a memory external to the programmable logic circuit FPGA, which in turn has two drawbacks:
  • the invention also proposes an implementation of the hardware accelerator on an FPGA programmable logic circuit, but unlike the prior art, the invention proposes an implementation that is both complete of the whole of the neural network (and therefore of all the layers of this neural network) and specifically dedicated to this neural network:
  • Embodiments of the invention enable the implementation of an automatic construction chain for a hardware accelerator of a binarized complex convolutional neural network algorithm.
  • the present invention provides a method of implementing a hardware accelerator of a neural network, comprising: a step of interpreting an algorithm of the neural network in binary format, converting the network algorithm neurons in binary format in a graph representation, selecting basic blocks from a library of predetermined basic blocks, performing an organization of the selected basic blocks, configuring internal parameters of the basic blocks of the organization, so that the organization of the selected and parameterized basic blocks corresponds to said representation in the form of a graph, a step of determining an initial set of weights of the neural network, a step of complete synthesis of the organization of the basic blocks selected and configured on the one hand on a programmable logic circuit FPGA preselected in a hardware accelerator of the neurons and on the other hand in pilot software for this hardware accelerator, this hardware accelerator being specifically dedicated to the neural network so as to be representative of the entire architecture of the neural network without requiring access to an external memory to the programmable logic circuit FPGA during the passage from one layer to another layer of the neural network, a step of loading the initial set of weights of
  • the present invention also provides an electronic card comprising: an FPGA programmable logic circuit, a memory external to the FPGA programmable logic circuit, a hardware accelerator of a neural network: entirely implemented on the FPGA programmable logic circuit, specifically dedicated to the neural network so as to be representative of the entire architecture of the neural network without requiring access to an external memory to the programmable logic circuit FPGA when moving from one layer to another layer of the neural network, comprising: an interface to the external memory, an interface to the outside of the electronic card, an acceleration core comprising successively: an information reading block, an information serialization block with two output channels, 'one to send input data to the layers of the neural network, the other to configure weights at the layers of the neural network, the layers of the neural network, an information deserialization block, an information write block.
  • the information read block includes a buffer memory
  • the information write block includes a buffer memory
  • the present invention also provides an on-board device comprising an electronic card according to the invention.
  • a device is on-board makes the gain in speed and performance particularly critical, for a given mass and a consumed energy that the user of the neural network both seeks to reduce as much as possible, while retaining the efficiency, and while ensuring simplicity and ease of use of the implementation process for the designer and the producer of the neural network.
  • the on-board device according to the invention is an on-board computer vision device.
  • the invention comprises one or more of the following features which can be used separately or in partial combination with one another or in total combination with one or other of the aforementioned objects of the invention.
  • the method of implementing a hardware accelerator of a neural network comprises, before the interpretation step, a step of binarization of the neural network algorithm, including an operation of compressing an floating point format to binary format.
  • This prior compression operation will make it possible to transform the neural network algorithm to make it even easier to handle in the following steps of the implementation method according to the invention which can therefore also thus accept as input a wider range of neural network algorithms.
  • the method of implementing a hardware accelerator of a neural network comprises, before the interpretation step, a step of selecting from a library of predetermined models of neural network algorithms already in binary format. .
  • the speed of progress of the implementation method according to the invention can be further significantly accelerated, which is particularly advantageous in the case of similar or repetitive tasks.
  • the internal parameters include the size of the neural network input data.
  • the size of the input data is a very useful element in configuring the base blocks more efficiently, and this element is readily available, so it is an element to advantageously be integrated into the configuration of the base blocks.
  • RAM Random Access Memory
  • a higher number of logical subcomponents included in each calculation block can in particular facilitate the realization of the logical synthesis, at the cost of an increase in its overall complexity and therefore in its cost price.
  • the compute block has a higher throughput, at the cost of complexity and higher cost.
  • the neural network is convolutional, and the internal parameters also include the sizes of the convolutions of the neural network.
  • This type of neural network is particularly interesting, but it is also a little more complex to implement.
  • the neural network algorithm in binary format is in the ONNX format ("Open Neural Network eXchange").
  • This format is particularly interesting, making the overall implementation process smoother.
  • the organization of the selected and configured basic blocks is described by a VHDL code representative of an acceleration core of the hardware accelerator.
  • This type of coding is particularly interesting, making the overall description of the architecture more complete.
  • the synthesizing step and the loading step are carried out by a communication between a host computer and an electronic FPGA card including the programmable logic circuit FPGA, this communication being advantageously carried out by means of the OpenCL standard through d 'a PCI Express type communication channel.
  • This type of communication channel and standard are particularly interesting, making the overall implementation process smoother.
  • the neural network is a neural network applied to computer vision, preferably to on-board computer vision.
  • the application to computer vision is an application to a surveillance camera, or else an application to an image classification system, or else an application to a vision device on board a motor vehicle.
  • the application to computer vision is an application to a surveillance camera, or else an application to an image classification system, or else an application to a vision device on board a motor vehicle.
  • FIG. 1 schematically represents an example of a functional architecture allowing the implementation of the method of implementing a hardware accelerator of a neural network according to one embodiment of the invention.
  • FIG. 2 schematically represents an example of an example of software architecture allowing the implementation of the method of implementing a hardware accelerator of a neural network according to one embodiment of the invention.
  • FIG. 3 Fa Figure 3 schematically shows an example of an electronic card implementing a hardware accelerator of a neural network according to one embodiment of the invention.
  • FIG. 4 schematically represents an example of a core of an electronic card implementing a hardware accelerator of a neural network according to one embodiment of the invention.
  • FIG. 1 schematically represents an example of a functional architecture allowing the implementation of the method of implementing a hardware accelerator of a neural network according to one embodiment of the invention.
  • the architecture has three layers: Layer 1 of the models, Layer 5 of the software stack, and Layer 8 of the hardware stack.
  • Layer 1 of models includes a library 2 of binary models already in ONNX format of neural network algorithms, and a set of 3 models of neural network algorithms which are pre-trained but in a floating point format ( 32 bits), including notably TENSORFLOW, PYTORCH, and CAFFEE2.
  • the neural network hardware accelerator implementation method has two possible inputs: either a model already present in library 2 or a model conventionally pre-trained in a non-fixed software architecture format ("framework in English language) belonging to to set 3.
  • a software architecture to be easily compatible with this implementation method, it is interesting that there is a converter from this software architecture to the ONNX format, ONNX being a transversal representation of all software architectures.
  • This set 3 of models of algorithms of pre-trained neural networks but in a floating point format can be binarized by a binariser 4, possibly equipped with an additional function of re-training of the neural network for example for PYTORCH, transforming the neural network algorithm models from a floating point format to a binary format, preferably to the ONNX binary format.
  • Layer 8 of the hardware stack comprises a library 9 of components, more precisely a library 9 of predetermined basic blocks which will be selected and assembled together and while each being parameterized, by layer 5 of the software stack, and more precisely by the constructor block 6 of layer 5 of the software stack.
  • Layer 5 of the software stack comprises, on the one hand, the constructor block 6 which will generate both the hardware accelerator of the neural network and the software piloting this hardware accelerator of the neural network, and on the other hand the block driver 7 which will use the driver software to drive the hardware accelerator of the neural network.
  • the constructor block 6 comprises several functions among which: a graph compilation function from a binarized neural network algorithm, a code generation function in VHDL format (coming from “VHSIC Hardware Description Language” in English language with VHSIC coming from "Very High Speed Integrated Circuit” in English language), this code in VHDL format containing information both for the implementation of the hardware accelerator of the neural network and for the driver software of this accelerator hardware, a synthesis function allowing the effective implementation of the hardware neural network accelerator on an FPGA programmable logic circuit.
  • the two inputs of the neural network accelerator implementation method have come together in builder block step 6, which will study the neural network input algorithm and convert it into a clean graph representation.
  • VHDL code describing the hardware accelerator including the acceleration core, as well as the driver software of this hardware accelerator, which remains to be synthesized at using synthesis tools, as well as the corresponding neural network configuration weights.
  • the pilot block 7 comprises several functions among which: a function of loading the VHDL code, a programming interface, and a function of communication between the host computer and the programmable logic circuit FPGA based on the technology of the infrastructure.
  • OpenCL software for "Open Computing Language” in English.
  • the pilot block 7 which integrates an application programming interface (API for "Application Programming Interface") for example by Python programming language and C ++ programming language, is used to drive the hardware accelerator.
  • API Application Programming Interface
  • Communication between the host computer and the FPGA is based on OpenCL technology which is a standard.
  • One of the advantageous features of the neural network hardware accelerator implementation method proposed by the invention is to be compatible with complex neural network structures such as “ResNet” (for “Residential Network”). or even “GoogLeNet”. These neural networks have the particularity of having divergent data paths, which are then merged or not according to various techniques (an "elt-wise” layer being the most common, for "element-wise” in English).
  • the graph compiler located in builder block 6 recognizes these peculiarities and translates them correctly into a corresponding hardware accelerator architecture.
  • FIG. 2 schematically represents an example of a software architecture allowing the implementation of the method of implementing a hardware accelerator of a neural network according to one embodiment of the invention.
  • a drive block 20 corresponds to the re-training function of the binarizer 4 of Figure 1
  • a block 30 of an FPGA tool kit corresponds to the builder block 6 of Figure 1.
  • a convolutional neural network (CNN) algorithm model 12 for example in a TENSORFLOW, CAFFEE, or PYTORCH format, is transformed into a convolutional neural network algorithm model 10 binarized in ONNX format which is sent to an input of a training block 20.
  • a set 11 of training data is sent to another input of this training block 20 to be transformed into trained weights 23 by interaction with a description 22 of the neural network.
  • An internal representation conversion 21 is made of the binarized convolutional neural network algorithm model 10 in ONNX format towards the description 22 of the neural network which by interaction on the training data set 11 gives the trained weights 23 which will be sent to an input of the block 30 of the FPGA tool kit.
  • the description 22 of the neural network is again converted by internal representation 24 to a binarized convolutional neural network algorithm 25 in ONNX format which in turn will be sent to another input in the toolkit block 30.
  • FPGA convolutional neural network
  • the binarized convolutional neural network algorithm 25 in ONNX format is converted by internal representation 32 and transformed by the cooperation of the construction function 33 and a data converter 34 having received the trained weights 23, to output on the one hand an instantiation 35 of files (in “.vhd”) and on the other hand a set of weights 36 (in “.data”), all with the aid of libraries 37 in C and C ++ programming languages.
  • the data converter 34 on the one hand puts the training weights in the right format and on the other hand associates them, in the form of a header, with guides to arrive at the right destinations in the right layers of the neural network .
  • the internal representation 32, the construction function 33 and the data converter 34 are grouped together in a sub-block 31.
  • the pair formed by the instantiation 35 of files and by the set of weights 36 can then either be compiled by an FPGA compiler 14, which can however take a considerable amount of time. , or possibly be associated with a model already precompiled in a precompiled library FPGA 13, which will be much faster but of course requires that this pair correspond to an already precompiled model which exists in stock in the precompiled library FPGA 13.
  • FIG. 3 schematically shows an example of an electronic card implementing a hardware accelerator of a neural network according to one embodiment of the invention.
  • a host computer integrating both a host processor 46 and a random access memory 47 (RAM for "Random Access Memory” in English), storing the data 48 useful for the hardware accelerator of the neural network, communicates bidirectionally by the 'intermediary of a serial local bus 49 advantageously of the PCIe type (for "PCI Express” in English with PCI for "Peripheral Component Interconnect” in English) with the FPGA electronic card 40 implementing the hardware accelerator of the neural network, and in particular its acceleration core 42.
  • the FPGA electronic card 40 comprises an FPGA chip 41. This FPGA chip 41 houses the acceleration core 42 as well as a BSP interface 43 (for “Board Support Package” in English).
  • the FPGA chip 41 communicates with a memory 44 integrated on the FPGA electronic card 40 via a DDR bus 45.
  • the memory 44 is a memory internal to the FPGA electronic card. 40, but external to the FPGA electronic chip 41; it has a high flow rate.
  • This memory 44 is advantageously a memory of the DDR or DDR-2 type (in fact DDR SDRAM for “Double Data Rate Synchronous Dynamic Random Access Memory” in English).
  • neither the memory 47 external to the FPGA electronic card 40, nor the memory 44 internal to the FPGA electronic card 40 but external to the chip FPGA 41, are not read to load part of the hardware accelerator, unlike the prior art. Indeed, for the invention, the entire architecture of the neural network is loaded all at once at the start into the acceleration core 42 of the FPGA chip 41, while for the prior art, each layer is charged separately after use of the previous layer which it will then replace, exhibiting a time and an exchange volume between the FPGA chip 41 and the outside of this FPGA chip 41 much greater than those of the invention for the same type of operation of the neural network implemented, therefore offering an operating efficiency much lower than that of the invention.
  • the hardware accelerator is specifically dedicated to the neural network that the hardware accelerator can be loaded in one go; on the contrary, in the prior art, the hardware accelerator is general-purpose, and it is then necessary to load it layer by layer in order to “reprogram” it for each new layer, loading in one go not being for the prior art. possible without resorting to a very large size for the hardware accelerator.
  • the topology is multi-layered, which allows it to be implemented entirely in one go without requiring too large a size for the hardware accelerator, while in the prior art, the general-purpose hardware accelerator implements different topologies, one topology by each layer.
  • FIG. 3 thus represents the overall architecture of the system comprising on the one hand the host machine including host processor 46 and host memory 47, on which the host machine the user performs actions, and on the other hand the hardware accelerator implemented on the FPGA electronic card 40.
  • the host processor 46 which is general-purpose, controls and sends inputs / outputs, via a high-speed communication channel 49, to the FPGA electronic card 40 accelerator provided with an FPGA chip 41 (FPGA programmable logic circuit) which FPGA chip 41 advantageously supports the “OpenCL” standard.
  • FPGA chip 41 FPGA programmable logic circuit
  • FIG. 4 schematically represents an example of a core of an electronic card implementing a hardware accelerator of a neural network according to one embodiment of the invention.
  • the acceleration core 42 communicates with the BSP interface 43 (also based on the “OpenCL” communication standard), this communication being represented more precisely in FIG. 4, via an “Avalon” reading interface 52 to a reader 50. , in particular to receive from the host computer the input images and the configuration of the neural network, and via an “Avalon” write interface 92 coming from a write block 90 to give the results obtained at the output of the neural network. Moreover, the acceleration core 42 receives the external parameters supplied by the user and more particularly from his call via the host processor, these external parameters arriving at the level of the buffer memory 55 of the reader 50, of the serialization block 60, and of the buffer memory 95 of the write block 90.
  • the acceleration core 42 comprises the series succession, first of the reader 50, then of the serialization block 60, then the layers 70 of the neural network itself, then again the deserialization block 80, and finally the block d 'write 90.
  • the signals arrive at the reader 50 through the read interface 52, exit from the write block 90 through the write interface 92, being passed successively through the serialization block 60. , layers 70 of the neural network, and of the deserialization block 80.
  • the management of the packets is ensured from start to the end, from the management of the packets 54 in the reader 50 to the management of the packets 94 in the block d 'writing 90, passing successively (dotted lines) through the serialization block 60, the layers 70 of the neural network, and the deserialization block 80.
  • Reader 50 includes at input a read interface 52 and at output a sending line 53 of input data (for the next block 60 of serialization) validated ready for use.
  • the reader 50 comprises a buffer memory 55 including registers 56 and 57 respectively receiving external parameters “pin” and “iter_i”.
  • the serialization block 60 transforms the data 53 arriving from the reader 50 into data 65 stored in the registers 61 to 64, for example in 512 registers even if only 4 registers are shown in FIG. 4. These data stored in the registers 61 to 64 will then be sent in the layers 70 of the neural network, either by the way of inference 77 for the input data of the neural network, or by the way of the configuration 78 for the configuration weights of the neural network .
  • a coach 68 selects either the inference path 77 or the configuration path 78 depending on the type of data to be sent to the layers 70 of the neural network.
  • the layers 70 of the neural network implement the multilayer topology of the neural network; here only 6 layers 71, 72, 73, 74, 75 and 76 are shown, but there may be more, or even significantly more, and also a little less.
  • the neural network comprises at least 2 layers, more preferably at least 3 layers, even more preferentially at least 5 layers, even advantageously at least 10 layers. It is preferably a convolutional neural network.
  • the deserialization block 80 stores, the data 87 arriving by way of inference 77, in the registers 81 to 84, for example in 512 registers even if only 4 registers are represented in FIG. 4. These data stored in the registers 81 to 84 will then be sent in the write block 90, more precisely on the output 85 of the deserialization block 80 to then be transmitted still to the input 93 of the write block 90.
  • These data 87 are the data of output from the neural network, the data resulting from the successive passage through layers 71 to 76 of neurons, that is to say that they correspond to the desired result obtained after processing by the neural network.
  • the write block 90 comprises at output a write interface 92 and at input a reception line 93 of the output data (from the previous deserialization block 80) validated ready to be transmitted to the outside of the acceleration core 42.
  • the write block 90 comprises a buffer memory 95 including registers 96 and 97 respectively receiving external parameters “pout” and “iter_o”.
  • a user will deport the inference of a “ResNet-50” type network from a general purpose microprocessor of the central processing unit type (CPU for “Central Processing Unit” in English) to a more suitable hardware target, in particular d 'from an energy performance point of view.
  • This user selects a target FPGA programmable logic circuit.
  • He can use a pre-trained neural network algorithm model in a format such as "PyTorch", which he can find on the internet.
  • This neural network algorithm model contains the configuration weights in a floating point representation of the neural network trained on a particular data set (“CIFAR-10” for example).
  • the user can then select this neural network algorithm model to use the method for implementing a neural network hardware accelerator according to the invention.
  • the user will then obtain at output an FPGA project which he will then synthesize before passing it on to an electronic card as well as a binarized configuration, compatible with the binary representation of the hardware neural network accelerator. This step will require the installation of proprietary tools corresponding to the target FPGA programmable logic circuit.
  • the user runs the scripts in builder block 6 automatically generating the configuration of the target FPGA programmable logic circuitry to provide the hardware accelerator.
  • the user uses the pilot block 7 in order to load the description of the accelerator (“ResNet-50” network) in the target FPGA programmable logic circuit, to provide the configuration of the pre-trained weights then binarized to the hardware accelerator, to provide an input image set, to retrieve the results of the neural network algorithm at the output of the hardware accelerator.
  • the relatively time-consuming part of generating the hardware architecture from the "PyTorch" representation can be dispensed with, provided you use the models from the precompiled network library. If the user chooses a hardware accelerator whose topology has already been generated (by himself or provided by the library of precompiled neural network algorithms), he only has to go through the step of binarization of the model weights which is very fast, for example of the order of a second.

Landscapes

  • Engineering & Computer Science (AREA)
  • Physics & Mathematics (AREA)
  • Theoretical Computer Science (AREA)
  • Health & Medical Sciences (AREA)
  • Life Sciences & Earth Sciences (AREA)
  • Biomedical Technology (AREA)
  • Biophysics (AREA)
  • Software Systems (AREA)
  • Computing Systems (AREA)
  • General Health & Medical Sciences (AREA)
  • Evolutionary Computation (AREA)
  • Molecular Biology (AREA)
  • Data Mining & Analysis (AREA)
  • General Engineering & Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Mathematical Physics (AREA)
  • Computational Linguistics (AREA)
  • Artificial Intelligence (AREA)
  • Neurology (AREA)
  • Advance Control (AREA)

Abstract

L'invention concerne un procédé d'implémentation d'un accélérateur matériel d'un réseau de neurones, comprenant : une étape d'interprétation d'un algorithme du réseau de neurones en format binaire, convertissant l'algorithme de réseau de neurones en format binaire en une représentation sous forme de graphe, sélectionnant des blocs de base dans une bibliothèque de blocs de base prédéterminés, réalisant une organisation des blocs de base sélectionnés, configurant des paramètres internes des blocs de base de l'organisation, de sorte que l'organisation des blocs de base sélectionnés et paramétrés corresponde à ladite représentation sous forme de graphe, une étape de détermination d'un jeu initial de poids du réseau de neurones, une étape de synthétisation complète de l'organisation des blocs de base sélectionnés et paramétrés d'une part sur un circuit logique programmable FPGA (41) présélectionné en un accélérateur matériel (42) du réseau de neurones et d'autre part en un logiciel pilote de cet accélérateur matériel (42), cet accélérateur matériel (42) étant spécifiquement dédié au réseau de neurones de manière à être représentatif de l'ensemble de l'architecture du réseau neurones sans nécessiter d'accès à une mémoire externe (44) au circuit logique programmable FPGA (41) lors du passage d'une couche à une autre couche du réseau de neurones, une étape de chargement (48) du jeu initial de poids du réseau de neurones dans l'accélérateur matériel (42).

Description

DESCRIPTION
PROCEDE D’IMPLEMENTATION D’UN ACCELERATEUR MATERIEL D’UN
RESEAU DE NEURONES
DOMAINE DE L’INVENTION
L’invention concerne le domaine des procédés d’implémentation d’un accélérateur matériel d’un réseau de neurones, ainsi que le domaine des cartes électroniques implémentant un accélérateur matériel d’un réseau de neurones. Un procédé d’implémentation d’un accélérateur matériel d’un réseau de neurones est un procédé d’implémentation d’un accélérateur matériel d’un algorithme de réseau de neurones.
ARRIERE PLAN TECHNOLOGIQUE DE L’INVENTION
Les procédés d’implémentation d’un accélérateur matériel d’un réseau de neurones permettent de créer et d’entraîner des réseaux de neurones spécifiques sur une cible matérielle reconfigurable (FPGA pour « Field-Programmable Gâte Array » en langue anglaise) puis de les utiliser sur des jeux de données. Plusieurs difficultés techniques peuvent être mises en évidence, tant du point de vue matériel que logiciel.
Du point de vue logiciel, il peut y avoir la nécessité de binariser les réseaux de neurones, la volonté de réduire la perte de précision, l’intérêt de pouvoir automatiser la binarisation d’un réseau de neurones en représentation flottante, la portabilité du réseau binaire entraîné sur la cible matérielle reconfigurable FPGA, l’utilisation d’une série d’outils complexes.
Du point de vue matériel, il peut y avoir l’architecture complexe des réseaux de neurones et surtout des réseaux de neurones convolutifs, la difficulté du passage à l’échelle de composants génériques, le foisonnement actuel des nouveaux types de réseaux de neurones (éventuellement à tester), la recherche d’un niveau de performance par unité de puissance (en watts) consommée assez élevée et qui peut même devenir très élevé pour le domaine de l’embarqué.
En plus de toutes ces exigences difficiles et parfois partiellement contradictoires soulevées par l’art antérieur, l’invention s’intéresse à réaliser également, pour ces procédés d’implémentation d’un accélérateur matériel d’un réseau de neurones, d’une part une simplification de l’utilisation pour un utilisateur non expert pour l’aspect logiciel et d’autre part une certaine automatisation dans la façon d’utiliser une série d’outils assez complexes à manipuler et requérant un niveau relativement élevé d’expertise. Selon un premier art antérieur, il est connu d’implémenter un accélérateur matériel d’un réseau de neurones sur un circuit logique programmable FPGA (Field Programmable Gâte Array).
Mais le fonctionnement de cet accélérateur matériel présente deux inconvénients :
d’une part il est relativement lent,
et d’autre part, son ratio performance (performance de calcul ou autre performance de traitement de données) sur énergie consommée est assez insuffisant.
Bon nombre de grands constructeurs de cibles matérielles reconfigurables FPGA ont essayé de mettre sur le marché des solutions d’accélération de type apprentissage profond (« Deep Learning » en langue anglaise) et ont essayé alors d’englober le plus grand nombre possible d’algorithmes différents de réseaux de neurones, afin d’être capable de s’adresser au plus grand nombre d’utilisateurs potentiels. En conséquence, leur accélérateur matériel de réseau de neurones a adopté une architecture permettant de traiter de manière similaire des réseaux de neurones de structures et de tailles complètement différentes, allant ainsi du plus simple au plus complexe. Ce type d’architecture est qualifiée de systolique, elle utilise des éléments de calculs reliés entre eux sous la forme d’une matrice, ces éléments de calculs étant nourris avec une mémoire cache à accès direct (DMA pour « Direct Access Memory » en langue anglaise) laquelle enchaîne les chargements et enregistrements de poids et d’activations à partir d’une mémoire externe au circuit logique programmable FPGA.
OBJETS DE L’INVENTION
Le but de la présente invention est de fournir un procédé d’implémentation d’un accélérateur matériel d’un réseau de neurones palliant au moins partiellement les inconvénients précités.
En effet, selon l’analyse de l’invention, cette implémentation de l’art antérieur reste très généraliste, c’est-à-dire qu’elle conserve une matrice d’éléments de calcul comme noyau d’accélération qui doit régulièrement, à chaque nouvelle couche du réseau de neurones ou à chaque nouvelle opération effectuée par le réseau de neurones, être rechargée et même reprogrammée avec des paramètres stockés dans une mémoire externe au circuit logique programmable FPGA, ce qui présente à son tour deux inconvénients :
c’est long de recharger le noyau d’accélération à chaque fois,
et cette structure « généraliste et universelle » est plus difficile à optimiser en termes de ratio performance sur énergie consommée. L’invention propose également une implémentation de l’accélérateur matériel sur un circuit logique programmable FPGA, mais au contraire de l’art antérieur, l’invention propose une implémentation à la fois complète de l’ensemble du réseau de neurones (et donc de l’ensemble de toutes les couches de ce réseau de neurones) et spécifiquement dédiée à ce réseau de neurones :
supprimant ainsi le recours permanent à la mémoire externe, améliorant ainsi notablement la vitesse de fonctionnement de cet accélérateur matériel,
et permettant également une meilleure optimisation du ratio performance sur énergie consommée, améliorant ainsi également l’efficacité de fonctionnement de cet accélérateur matériel,
mais utilisant cependant des briques prédéfinies d’une bibliothèque commune pour les différentes implémentations,
ces briques étant toutefois facilement utilisables grâce à la mise en forme spécifique préalable de l’algorithme du réseau de neurones, cette mise en forme spécifique correspondant à la représentation sous forme de graphe,
ceci afin de conserver avantageusement au procédé d’implémentation des caractères :
o relativement simple et aisé pour son déroulement,
o et accessible même à des concepteurs et à des réalisateurs qui ne seraient pas des spécialistes chevronnés de la fabrication d’accélérateur matériel de réseau de neurones.
Des modes de réalisation de l’invention permettent la mise en œuvre d’une chaîne de construction automatique pour accélérateur matériel d’algorithme de réseaux de neurones convolutifs complexes binarisés.
A cette fin, la présente invention propose un procédé d’implémentation d’un accélérateur matériel d’un réseau de neurones, comprenant : une étape d’interprétation d’un algorithme du réseau de neurones en format binaire, convertissant l’algorithme de réseau de neurones en format binaire en une représentation sous forme de graphe, sélectionnant des blocs de base dans une bibliothèque de blocs de base prédéterminés, réalisant une organisation des blocs de base sélectionnés, configurant des paramètres internes des blocs de base de l’organisation, de sorte que l’organisation des blocs de base sélectionnés et paramétrés corresponde à ladite représentation sous forme de graphe, une étape de détermination d’un jeu initial de poids du réseau de neurones, une étape de synthétisation complète de l’organisation des blocs de base sélectionnés et paramétrés d’une part sur un circuit logique programmable FPGA présélectionné en un accélérateur matériel du réseau de neurones et d’autre part en un logiciel pilote de cet accélérateur matériel, cet accélérateur matériel étant spécifiquement dédié au réseau de neurones de manière à être représentatif de l’ensemble de l’architecture du réseau neurones sans nécessiter d’accès à une mémoire externe au circuit logique programmable FPGA lors du passage d’une couche à une autre couche du réseau de neurones, une étape de chargement du jeu initial de poids du réseau de neurones dans l’accélérateur matériel.
A cette fin, la présente invention propose également une carte électronique comprenant : un circuit logique programmable FPGA, une mémoire externe au circuit logique programmable FPGA, un accélérateur matériel d’un réseau de neurones : entièrement implémenté sur le circuit logique programmable FPGA, spécifiquement dédié au réseau de neurones de manière à être représentatif de l’ensemble de l’architecture du réseau neurones sans nécessiter d’accès à une mémoire externe au circuit logique programmable FPGA lors du passage d’une couche à une autre couche du réseau de neurones, comprenant : une interface vers la mémoire externe, une interface vers l’extérieur de la carte électronique, un noyau d’accélération comprenant successivement : un bloc de lecture d’information, un bloc de sérialisation d’information avec deux voies de sortie, l’une pour envoyer des données d’entrée aux couches du réseau de neurones, l’autre pour configurer des poids au niveau des couches du réseau de neurones, les couches du réseau de neurones, un bloc de désérialisation d’information, un bloc d’écriture d’information.
De préférence, le bloc de lecture d’information comprend une mémoire tampon, et le bloc d’écriture d’information comprend une mémoire tampon.
L’utilisation de ces mémoires tampon permet de ne pas imposer le rythme du noyau d’accélération au reste du système.
A cette fin, la présente invention propose encore un appareil embarqué comprenant une carte électronique selon l’invention.
Le fait pour un appareil d’être embarqué rend particulièrement critique le gain de vitesse et de performance, pour une masse donnée et une énergie consommée que l’utilisateur du réseau de neurones cherche toutes deux à réduire le plus possible, tout en conservant l’efficacité, et tout en garantissant simplicité et facilité d’utilisation du procédé d’implémentation pour le concepteur et le réalisateur du réseau de neurones.
De préférence, l’appareil embarqué selon l’invention est un appareil embarqué de vision par ordinateur.
Suivant des modes de réalisation préférés, l’invention comprend une ou plusieurs des caractéristiques suivantes qui peuvent être utilisées séparément ou en combinaison partielle entre elles ou en combinaison totale entre elles, avec l’un ou l’autre des objets précités de l’invention.
De préférence, le procédé d’implémentation d’un accélérateur matériel d’un réseau de neurones comporte, avant l’étape d’interprétation, une étape de binarisation de l’algorithme de réseau de neurones, incluant une opération de compression d’un format en virgule flottante vers un format binaire.
Cette opération de compression préalable va permettre de transformer l’algorithme de réseau de neurones pour le rendre encore plus facile à manipuler dans les étapes suivantes du procédé d’implémentation selon l’invention qui peut donc aussi ainsi accepter en entrée un éventail plus large d’algorithmes de réseau de neurones.
De préférence, le procédé d’implémentation d’un accélérateur matériel d’un réseau de neurones comporte, avant l’étape d’interprétation, une étape de sélection dans une bibliothèque de modèles prédéterminés d’algorithmes de réseau de neurones déjà en format binaire.
Ainsi, la vitesse de déroulement du procédé d’implémentation selon l’invention peut encore être nettement accélérée, ce qui est particulièrement intéressant dans le cas de tâches similaires ou répétitives.
De préférence, les paramètres internes comprennent la taille des données d’entrée du réseau de neurones.
La taille des données d’entrée est un élément très utile pour configurer les blocs de base de manière plus efficace, et cet élément est facilement disponible, c’est donc un élément à avantageusement intégrer de manière privilégiée dans la configuration des blocs de base.
D’autres paramètres internes peuvent également comprendre d’une part le nombre de sous-composants logiques inclus dans chaque bloc de mémoire vive (RAM pour « Random Access Memory » en langue anglaise) et/ou d’autre part le parallélisme du bloc de calcul, c’est-à-dire le nombre de mots traités par cycle d’horloge.
Un nombre plus élevé de sous-composants logiques inclus dans chaque bloc de calcul peut notamment faciliter la réalisation de la synthèse logique, au prix d’une augmentation de sa complexité globale et donc de son coût de revient.
Plus le parallélisme du bloc de calcul est élevé, plus le nombre de mots traités par cycle d’horloge est élevé. Ainsi le bloc de calcul a un débit plus élevé, au prix d’une complexité et d’un coût plus élevé.
De préférence, le réseau de neurones est convolutif, et les paramètres internes comprennent aussi les tailles des convolutions du réseau de neurones. Ce type de réseau de neurones est particulièrement intéressant, mais il est également un peu plus complexe à implémenter.
De préférence, l’algorithme du réseau de neurones en format binaire est sous le format ONNX (« Open Neural Network eXchange » en langue anglaise).
Ce format est particulièrement intéressant, rendant globalement le procédé d’implémentation plus fluide.
De préférence, l’organisation des blocs de base sélectionnés et paramétrés est décrite par un code VHDL représentatif d’un noyau d’accélération de l’accélérateur matériel.
Ce type de codage est particulièrement intéressant, rendant globalement la description de l’architecture plus complète.
De préférence, l’étape de synthétisation et l’étape de chargement sont réalisées par une communication entre un ordinateur hôte et une carte électronique FPGA incluant le circuit logique programmable FPGA, cette communication étant avantageusement réalisée par l’intermédiaire du standard OpenCL au travers d’un canal de communication de type PCI Express.
L’utilisation d’une communication, directe et immédiate entre un ordinateur hôte et une carte électronique FPGA incluant le circuit logique programmable FPGA, rend globalement le procédé d’implémentation plus facile à mettre en œuvre pour le concepteur et le réalisateur du réseau de neurones.
Ce type de canal de communication et de standard sont particulièrement intéressants, rendant globalement le procédé d’implémentation plus fluide.
De préférence, le réseau de neurones est un réseau de neurones appliqué à la vision par ordinateur, de préférence à la vision par ordinateur embarqué.
Dans ce domaine d’application de la vision par ordinateur, et surtout intégré dans des dispositifs embarqués (donc pas dans des dispositifs qui seraient fixes dans une station informatique au sol), les exigences simultanées d’efficacité, de rapidité et de faible consommation d’énergie, entraînent des optimisations poussées peu compatibles avec une simplification du procédé d’implémentation d’un accélérateur matériel du réseau de neurones, ce que l’invention a pourtant choisi de faire, car ce compromis inhabituel en fait fonctionne bien.
De préférence, l’application à la vision par ordinateur est, une application à une caméra de surveillance, ou bien une application à un système de classification d’images, ou bien une application à un dispositif de vision embarqué sur véhicule automobile. D'autres caractéristiques et avantages de l'invention apparaîtront à la lecture de la description qui suit d’un mode de réalisation préféré de l'invention, donnée à titre d'exemple et en référence aux dessins annexés.
BREVE DESCRIPTION DES DESSINS
[Fig. 1] Fa figure 1 représente schématiquement un exemple d’architecture fonctionnelle permettant la mise en œuvre du procédé d’implémentation d’un accélérateur matériel d’un réseau de neurones selon un mode de réalisation de l’invention.
[Fig. 2] Fa figure 2 représente schématiquement un exemple un exemple d’architecture logicielle permettant la mise en œuvre du procédé d’implémentation d’un accélérateur matériel d’un réseau de neurones selon un mode de réalisation de l’invention.
[Fig. 3] Fa figure 3 représente schématiquement un exemple d’une carte électronique implémentant un accélérateur matériel d’un réseau de neurones selon un mode de réalisation de l’invention.
[Fig. 4] Fa figure 4 représente schématiquement un exemple d’un noyau d’une carte électronique implémentant un accélérateur matériel d’un réseau de neurones selon un mode de réalisation de l’invention.
DESCRIPTION DETAILLEE DES MODES DE REALISATION DE L’INVENTION
La figure 1 représente schématiquement un exemple d’architecture fonctionnelle permettant la mise en œuvre du procédé d’implémentation d’un accélérateur matériel d’un réseau de neurones selon un mode de réalisation de l’invention.
L’architecture comporte trois couches : la couche 1 des modèles, la couche 5 de la pile logicielle, et la couche 8 de la pile matérielle.
La couche 1 des modèles comporte une librairie 2 de modèles binaires déjà en format ONNX d’algorithmes de réseaux de neurones, et un ensemble 3 de modèles d’algorithmes de réseaux de neurones qui sont pré-entraînés mais sous un format en virgule flottante (32 bits), parmi lesquels notamment TENSORFLOW, PYTORCH, et CAFFEE2. Fe procédé d’implémentation d’accélérateur matériel de réseau de neurones possède deux entrées possibles : soit un modèle déjà présent en librairie 2 soit un modèle pré-entrainé classiquement dans un format d’architecture logicielle (« framework en langue anglaise) non fixée appartenant à l’ensemble 3. Pour qu’une architecture logicielle soit facilement compatible avec ce procédé d’implémentation, il est intéressant qu’il existe un convertisseur de cette architecture logicielle vers le format ONNX, ONNX étant une représentation transversale à toutes les architectures logicielles.
Cet ensemble 3 de modèles d’algorithmes de réseaux de neurones pré-entraînés mais sous un format en virgule flottante peuvent être binarisés par un binariseur 4, éventuellement doté d’une fonction supplémentaire de réentraînement du réseau de neurones par exemple pour PYTORCH, transformant les modèles d’algorithmes de réseaux de neurones d’un format en virgule flottante vers un format binaire, préférentiellement vers le format binaire ONNX.
La couche 8 de la pile matérielle comporte une bibliothèque 9 de composants, plus précisément une bibliothèques 9 de blocs de base prédéterminés qui vont être sélectionnés et assemblés entre eux et tout en étant chacun paramétrés, par la couche 5 de la pile logicielle, et plus précisément par le bloc constructeur 6 de la couche 5 de la pile logicielle.
La couche 5 de la pile logicielle comporte, d’une part le bloc constructeur 6 qui va générer aussi bien l’accélérateur matériel du réseau de neurones que le logiciel pilote de cet accélérateur matériel du réseau de neurones, et d’autre part le bloc pilote 7 qui va utiliser le logiciel pilote pour piloter l’accélérateur matériel du réseau de neurones.
Plus précisément, le bloc constructeur 6 comprend plusieurs fonctions parmi lesquelles : une fonction de compilation de graphe à partir d’un algorithme binarisé de réseau de neurones, une fonction de génération de code en format VHDL (venant de « VHSIC Hardware Description Language » en langue anglaise avec VHSIC venant de « Very High Speed Integrated Circuit » en langue anglaise), ce code en format VHDL contenant les informations à la fois pour l’implémentation de l’accélérateur matériel du réseau de neurones et pour le logiciel pilote de cet accélérateur matériel, une fonction de synthèse permettant l’implémentation effective de l’accélérateur matériel de réseau de neurones sur un circuit logique programmable FPGA. Les deux entrées du procédé d’implémentation d’accélérateur de réseau de neurones se sont rejointes dans l’étape du bloc constructeur 6, qui va étudier l’algorithme d’entrée du réseau de neurones et le convertir dans une représentation en graphe propre. Après cette conversion de ce graphe, deux produits ont donc été générés : d’une part, le code VHDL décrivant l’accélérateur matériel dont le noyau d’accélération tout comme le logiciel pilote de cet accélérateur matériel, qu’il reste à synthétiser à l’aide d’outils de synthèse, ainsi que les poids de configuration du réseau de neurones correspondant.
Plus précisément, le bloc pilote 7 comprend plusieurs fonctions parmi lesquelles : une fonction de chargement du code VHDL, une interface de programmation, et une fonction de communication entre l’ordinateur hôte et le circuit logique programmable FPGA basée sur la technologie de l’infrastructure logicielle OpenCL (pour « Open Computing Language » en langue anglaise). Un fois l’accélérateur matériel synthétisé sur la cible choisie comme circuit logique programmable FPGA, par exemple à l’aide d’une suite d’outils propre au constructeur du circuit logique programmable FPGA, le bloc pilote 7, qui intègre une interface de programmation application (API pour « Application Programming Interface ») par exemple en langage de programmation Python et en langage de programmation C++, est utilisé pour piloter l’accélérateur matériel. La communication entre l’ordinateur hôte et le FPGA repose sur la technologie OpenCL qui est un standard.
Dès lors, une grande liberté est offerte à l’utilisateur qui peut créer son propre programme à la suite de la génération du noyau d’accélération et de la configuration. S’il souhaite cibler un circuit logique programmable FPGA particulier non prévu par le procédé d’implémentation d’accélérateur matériel de réseau de neurones selon l’invention, c’est encore possible, il suffit en effet pour cela que ce type de modèle de circuit logique programmable FPGA soit supporté par la suite d’outils du vendeur de ce circuit logique programmable FPGA.
Une des particularités avantageuses du procédé d’implémentation d’accélérateur matériel de réseau de neurones proposé par l’invention est d’être compatible avec des structures de réseaux de neurones complexes tels que « ResNet » (pour « Residential Network » en langue anglaise) ou encore « GoogLeNet ». Ces réseaux de neurones présentent la particularité d’avoir des chemins de donnée divergents, qui sont ensuite fusionnés ou non selon diverses techniques (une couche « elt-wise » étant la plus répandue, pour « element- wise » en langue anglaise).
Le compilateur de graphe situé dans le bloc constructeur 6 reconnaît ces particularités et les traduit correctement en une architecture d’accélérateur matériel correspondante.
La figure 2 représente schématiquement un exemple d’architecture logicielle permettant la mise en œuvre du procédé d’implémentation d’un accélérateur matériel d’un réseau de neurones selon un mode de réalisation de l’invention. Un bloc d’entraînement 20 correspond à la fonction réentraînement du binariseur 4 de la figure 1, et un bloc 30 de kit d’outils FPGA correspond au bloc constructeur 6 de la figure 1.
Un modèle 12 d’algorithme de réseau de neurones convolutif (CNN pour « Convolutional Neural Network » en langue anglaise), par exemple sous un format TENSORFLOW, CAFFEE, ou PYTORCH, est transformé en un modèle 10 d’algorithme de réseau de neurones convolutif binarisé en format ONNX qui est envoyé sur une entrée d’un bloc d’entraînement 20. Un jeu 11 de données d’entraînement est envoyé sur une autre entrée de ce bloc d’entraînement 20 pour être transformé en poids entraînés 23 par interaction avec une description 22 du réseau de neurones. Une conversion par représentation interne 21 est faite du modèle 10 d’algorithme de réseau de neurones convolutif binarisé en format ONNX vers la description 22 du réseau de neurones qui par interaction sur le jeu 11 de données d’entraînement donne les poids entraînés 23 qui vont être envoyés sur une entrée du bloc 30 de kit d’outils FPGA. Après quoi, la description 22 du réseau de neurones est à nouveau convertie par représentation interne 24 vers un algorithme 25 de réseau de neurones convolutif binarisé en format ONNX lequel à son tour va être envoyé vers une autre entrée du bloc 30 de kit d’outils FPGA.
L’algorithme 25 de réseau de neurones convolutif binarisé en format ONNX est converti par représentation interne 32 et transformé par la coopération de la fonction construction 33 et d’un convertisseur de données 34 ayant reçu les poids entraînés 23, pour donner en sortie d’une part une instanciation 35 de fichiers (en « .vhd ») et d’autre part un jeu de poids 36 (en « .data »), le tout à l’aide de librairies 37 en langages de programmation C et C++. Le convertisseur de données 34 d’une part met les poids d’entraînement au bon format et d’autre part leur associe, sous forme d’un en-tête, des guides pour arriver aux bonnes destinations dans les bonnes couches du réseau de neurones. La représentation interne 32, la fonction de construction 33 et le convertisseur de données 34, sont regroupés dans un sous- bloc 31.
En sortie du bloc 30 de kit d’outils FPGA, le couple formé par l’instanciation 35 de fichiers et par le jeu de poids 36, peut ensuite, soit être compilé par un compilateur FPGA 14, ce qui peut toutefois prendre un temps notable, soit être le cas échéant associé à un modèle déjà précompilé dans une libraire précompilée FPGA 13, ce qui sera beaucoup plus rapide mais bien sûr nécessite que ce couple corresponde à un modèle déjà précompilé qui existe en stock dans la libraire précompilée FPGA 13. Le résultat obtenu, que ce soit en provenance de la libraire précompilée FPGA 13 ou bien en provenance du compilateur FPGA 14, est un flot de configuration FPGA 15.
La figure 3 représente schématiquement un exemple un exemple d’une carte électronique implémentant un accélérateur matériel d’un réseau de neurones selon un mode de réalisation de l’invention.
Un ordinateur hôte intégrant à la fois un processeur hôte 46 et une mémoire vive 47 (RAM pour « Random Access Memory » en langue anglaise), stockant les données 48 utiles pour l’accélérateur matériel de réseau de neurones, communique de manière bidirectionnelle par l’intermédiaire d’un bus local série 49 avantageusement de type PCIe (pour « PCI Express » en langue anglaise avec PCI pour « Peripheral Component Interconnect » en langue anglaise) avec la carte électronique FPGA 40 implémentant l’accélérateur matériel du réseau de neurones, et en particulier son noyau d’accélération 42. La carte électronique FPGA 40 comprend une puce FPGA 41. Cette puce FPGA 41 abrite le noyau d’accélération 42 ainsi qu’une interface 43 BSP (pour « Board Support Package » en langue anglaise). La puce FPGA 41, et en particulier le noyau d’accélération 42, communique avec une mémoire 44 intégrée sur la carte électronique FPGA 40 par l’intermédiaire d’un bus DDR 45. La mémoire 44 est une mémoire interne à la carte électronique FPGA 40, mais externe à la puce électronique FPGA 41 ; elle présente un débit élevé. Cette mémoire 44 est avantageusement une mémoire de type DDR ou DDR-2 (en fait DDR SDRAM pour « Double Data Rate Synchronous Dynamic Random Access Memory » en langue anglaise).
Lors du passage d’une couche à une autre couche dans le réseau de neurones, dans l’invention, ni la mémoire 47 externe à la carte électronique FPGA 40, ni la mémoire 44 interne à la carte électronique FPGA 40 mais externe à la puce FPGA 41, ne sont lues pour charger une partie de l’accélérateur matériel, au contraire de l’art antérieur. En effet, pour l’invention, l’ensemble de l’architecture du réseau de neurones est chargé en une seule fois au début dans le noyau d’accélération 42 de la puce FPGA 41, tandis que pour l’art antérieur, chaque couche est chargée séparément après utilisation de la couche précédente qu’elle va ensuite remplacer, présentant un temps et un volume d’échange entre la puce FPGA 41 et l’extérieur à cette puce FPGA 41 bien supérieurs à ceux de l’invention pour le même type de fonctionnement du réseau de neurones implémenté, offrant donc une efficacité de fonctionnement bien inférieure à celle de l’invention. C’est parce qu’il est spécifiquement dédié au réseau de neurones que l’accélérateur matériel peut être chargé en une seule fois ; au contraire, dans l’art antérieur, l’accélérateur matériel est généraliste, et il faut alors le charger couche par couche pour le « reprogrammer » à chaque nouvelle couche, un chargement en une seule fois n’étant pour l’art antérieur pas possible sans recourir à une taille très importante pour l’accélérateur matériel. Dans l’accélérateur matériel spécifique (et dédié) de l’invention, la topologie est multicouches, ce qui lui permet d’être implémentée entièrement en une seule fois sans requérir une taille trop importante pour l’accélérateur matériel, tandis que dans l’art antérieur, l’accélérateur matériel généraliste implémente différentes topologies, une topologie par chaque couche.
La Figure 3 représente ainsi l’architecture globale du système comprenant d’une part la machine hôte incluant processeur hôte 46 et mémoire hôte 47, sur laquelle machine hôte l’utilisateur effectue des actions, et d’autre part l’accélérateur matériel implémenté sur la carte électronique FPGA 40. Le processeur hôte 46, qui est généraliste, commande et envoie des entrées/sorties, via un canal de communication haut débit 49, à la carte électronique FPGA 40 accélératrice munie d’une puce FPGA 41 (circuit logique programmable FPGA) laquelle puce FPGA 41 supporte avantageusement le standard « OpenCL ».
La figure 4 représente schématiquement un exemple d’un noyau d’une carte électronique implémentant un accélérateur matériel d’un réseau de neurones selon un mode de réalisation de l’invention.
Le noyau d’accélération 42 communique avec l’interface BSP 43 (basé aussi sur le standard de communication « OpenCL »), cette communication étant représentée plus précisément sur la figure 4, via une interface de lecture « Avalon » 52 vers un lecteur 50, notamment pour recevoir de la part de l’ordinateur hôte les images d’entrée et la configuration du réseau de neurones, et via une interface d’écriture « Avalon » 92 en provenance d’un bloc d’écriture 90 pour donner les résultats obtenus en sortie du réseau de neurones. Par ailleurs le noyau d’accélération 42 reçoit les paramètres externes fournis par l’utilisateur et plus particulièrement depuis son appel via le processeur hôte, ces paramètres externes arrivant au niveau de la mémoire tampon 55 du lecteur 50, du bloc de sérialisation 60, et de la mémoire tampon 95 du bloc d’écriture 90.
Le noyau d’accélération 42 comprend la succession en série, d’abord du lecteur 50, puis du bloc de sérialisation 60, ensuite les couches 70 du réseau de neurones proprement dit, puis encore le bloc de désérialisation 80, et enfin le bloc d’écriture 90. Les signaux arrivent vers le lecteur 50 par l’interface de lecture 52, sortent en provenance du bloc d’écriture 90 par l’interface d’écriture 92, en étant passés successivement par l’intermédiaire du bloc de sérialisation 60, des couches 70 du réseau de neurones, et du bloc de désérialisation 80. La gestion des paquets est assurée du début à la fin, depuis la gestion des paquets 54 dans le lecteur 50 jusqu’à la gestion des paquets 94 dans le bloc d’écriture 90, en passant successivement (traits pointillés) par le bloc de sérialisation 60, les couches 70 du réseau de neurones, et le bloc de désérialisation 80.
Le lecteur 50 comprend en entrée une interface de lecture 52 et en sortie une ligne d’envoi 53 des données d’entrée (pour le bloc suivant 60 de sérialisation) validées prêtes à utilisation. Le lecteur 50 comprend une mémoire tampon 55 incluant des registres 56 et 57 recevant respectivement des paramètres externes « pin » et « iter_i ».
Le bloc de sérialisation 60 transforme les données 53 arrivant du lecteur 50 en données 65 stockées dans les registres 61 à 64, par exemple dans 512 registres même si seulement 4 registres sont représentés sur la figure 4. Ces données stockées dans les registres 61 à 64 vont ensuite être envoyées dans les couches 70 du réseau de neurones, soit par la voie de l’inférence 77 pour les données d’entrée du réseau de neurones, soit par la voie de la configuration 78 pour les poids de configuration du réseau de neurones. Un sélectionneur 68 sélectionne soit la voie de l’inférence 77 soit la voie de la configuration 78 selon le type de données à envoyer aux couches 70 du réseau de neurones.
Les couches 70 du réseau de neurones implémentent la topologie multicouche du réseau de neurones ; ici seulement 6 couches 71, 72, 73, 74, 75 et 76 sont représentées, mais il peut y en avoir plus, voire nettement plus, et également un peu moins. Préférentiellement, le réseau de neurones comprend au moins 2 couches, plus préférentiellement au moins 3 couches, encore plus préférentiellement au moins 5 couches, voire avantageusement au moins 10 couches. C’est préférentiellement un réseau de neurones convolutif.
Le bloc de désérialisation 80 stocke, les données 87 arrivant par la voie de l’inférence 77, dans les registres 81 à 84, par exemple dans 512 registres même si seulement 4 registres sont représentés sur la figure 4. Ces données stockées dans les registres 81 à 84 vont ensuite être envoyées dans le bloc d’écriture 90, plus précisément sur la sortie 85 du bloc de désérialisation 80 pour être ensuite transmises toujours vers l’entrée 93 du bloc d’écriture 90. Ces données 87 sont les données de sortie du réseau de neurones, les données issues du passage successif au travers des couches 71 à 76 de neurones, c’est-à-dire qu’elles correspondent au résultat recherché obtenu après traitement par le réseau de neurones.
Le bloc d’écriture 90 comprend en sortie une interface d’écriture 92 et en entrée une ligne de réception 93 des données de sortie (du bloc précédent 80 de désérialisation) validées prêtes à être transmises vers l’extérieur du noyau d’accélération 42. Le bloc d’écriture 90 comprend une mémoire tampon 95 incluant des registres 96 et 97 recevant respectivement des paramètres externes « pout » et « iter_o ».
Un exemple d’utilisation possible du procédé d’implémentation d’un accélérateur matériel de réseau de neurones selon l’invention est maintenant présenté. Un utilisateur va déporter l’inférence d’un réseau de type « ResNet-50 » d’un microprocesseur généraliste de type unité centrale de traitement (CPU pour « Central Processing Unit » en langue anglaise) vers une cible matérielle plus adaptée, notamment d’un point de vue de la performance énergétique. Cet utilisateur sélectionne un circuit logique programmable FPGA cible. Il peut utiliser un modèle d’algorithme de réseau de neurones pré-entrainé dans un format tel que « PyTorch », qu’il peut trouver sur internet. Ce modèle d’algorithme de réseau de neurones contient les poids de configuration dans une représentation en virgule flottante du réseau de neurones entraîné sur un jeu de donnée particulier (« CIFAR-10 » par exemple). L’utilisateur peut alors sélectionner ce modèle d’algorithme de réseau de neurones pour utiliser le procédé d’implémentation d’un accélérateur matériel de réseau de neurones selon l’invention. L’utilisateur va alors obtenir en sortie un projet FPGA qu’il va ensuite synthétiser avant de le passer sur carte électronique ainsi qu’une configuration binarisée, compatible avec la représentation binaire de l’accélérateur matériel de réseau de neurones. Cette étape va requérir l’installation d’outils propriétaires correspondant au circuit logique programmable FPGA cible.
Ensuite, l’utilisateur lance les scripts du bloc constructeur 6 générant automatiquement la configuration du circuit logique programmable FPGA cible pour fournir l’accélérateur matériel. Quand l’utilisateur dispose de cette sortie, il utilise le bloc pilote 7 afin, de charger la description de l’accélérateur (réseau « ResNet-50 ») dans le circuit logique programmable FPGA cible, de fournir la configuration des poids pré-entrainés puis binarisés à l’accélérateur matériel, de fournir un jeu d’image d’entrée, de récupérer les résultats de l’algorithme du réseau de neurones à la sortie de l’accélérateur matériel.
Il est possible de se passer de la partie relativement chronophage de la génération de l’architecture matérielle à partir de la représentation « PyTorch » à condition d’utiliser les modèles de la librairie de réseaux précompilés. Si l’utilisateur choisit un accélérateur matériel dont la topologie a déjà été générée (par lui-même ou fourni par la librairie de d’algorithmes de réseaux de neurones précompilés), il n’a plus qu’à passer par l’étape de binarisation des poids du modèle laquelle est très rapide, par exemple de l’ordre de la seconde.
Bien entendu, la présente invention n'est pas limitée aux exemples et au mode de réalisation décrits et représentés, mais elle est susceptible de nombreuses variantes accessibles à l'homme de l'art.

Claims

REVENDICATIONS
1. Procédé d’implémentation d’un accélérateur matériel d’un réseau de neurones, comprenant :
une étape (6, 30) d’interprétation d’un algorithme du réseau de neurones en format binaire,
o convertissant l’algorithme de réseau de neurones en format binaire (25) en une représentation sous forme de graphe,
o sélectionnant des blocs de base dans une bibliothèque (37) de blocs de base prédéterminés,
o réalisant (33) une organisation des blocs de base sélectionnés, o configurant des paramètres internes des blocs de base de l’organisation, o de sorte que l’organisation des blocs de base sélectionnés et paramétrés corresponde à ladite représentation sous forme de graphe,
une étape de détermination d’un jeu initial (36) de poids du réseau de neurones, une étape de synthétisation complète (13, 14) de l’organisation des blocs de base sélectionnés et paramétrés d’une part sur un circuit logique programmable FPGA (41) présélectionné en un accélérateur matériel (42) du réseau de neurones et d’autre part en un logiciel pilote de cet accélérateur matériel (42),
o cet accélérateur matériel (42) étant spécifiquement dédié au réseau de neurones de manière à être représentatif de l’ensemble de l’architecture du réseau neurones sans nécessiter d’accès à une mémoire externe (44) au circuit logique programmable FPGA (41) lors du passage d’une couche (71 à 75) à une autre couche (72 à 76) du réseau de neurones,
une étape de chargement (48) du jeu initial de poids du réseau de neurones dans l’accélérateur matériel (42).
2. Procédé d’implémentation d’un accélérateur matériel d’un réseau de neurones selon la revendication 1, caractérisé en ce qu’il comporte, avant l’étape d’interprétation (6, 30)), une étape de binarisation (4, 20) de l’algorithme de réseau de neurones, incluant une opération de compression d’un format en virgule flottante vers un format binaire.
3. Procédé d’implémentation d’un accélérateur matériel d’un réseau de neurones selon la revendication 1, caractérisé en ce qu’il comporte, avant l’étape d’interprétation (6, 30), une étape de sélection (2, 12) dans une bibliothèque (8, 37) de modèles prédéterminés d’algorithmes de réseau de neurones déjà en format binaire.
4. Procédé d’implémentation d’un accélérateur matériel d’un réseau de neurones selon l’une quelconque des revendications précédentes, caractérisé en ce que les paramètres internes comprennent la taille des données d’entrée du réseau de neurones.
5. Procédé d’implémentation d’un accélérateur matériel d’un réseau de neurones selon l’une quelconque des revendications précédentes, caractérisé en ce que le réseau de neurones est convolutif, et les paramètres internes comprennent aussi les tailles des convolutions du réseau de neurones.
6. Procédé d’implémentation d’un accélérateur matériel d’un réseau de neurones selon l’une quelconque des revendications précédentes, caractérisé en ce que l’algorithme du réseau de neurones en format binaire (25) est sous le format ONNX.
7. Procédé d’implémentation d’un accélérateur matériel d’un réseau de neurones selon l’une quelconque des revendications précédentes, caractérisé en ce que l’organisation des blocs de base sélectionnés et paramétrés est décrite par un code VHDL (15) représentatif d’un noyau d’accélération de l’accélérateur matériel (42).
8. Procédé d’implémentation d’un accélérateur matériel d’un réseau de neurones selon l’une quelconque des revendications précédentes, caractérisé en ce que l’étape de synthétisation (13, 14) et l’étape de chargement (48) sont réalisées par une communication entre un ordinateur hôte (46, 47) et une carte électronique FPGA (40) incluant le circuit logique programmable FPGA (41), cette communication étant avantageusement réalisée par l’intermédiaire du standard OpenCL au travers d’un canal de communication (49) de type PCI Express.
9. Procédé d’implémentation d’un accélérateur matériel d’un réseau de neurones selon l’une quelconque des revendications précédentes, caractérisé en ce que le réseau de neurones est un réseau de neurones appliqué à la vision par ordinateur, de préférence à la vision par ordinateur embarqué.
10. Procédé d’implémentation d’un accélérateur matériel d’un réseau de neurones selon la revendication 9, caractérisé en ce que l’application à la vision par ordinateur est, une application à une caméra de surveillance, ou bien une application à un système de classification d’images, ou bien une application à un dispositif de vision embarqué sur véhicule automobile.
11. Carte électronique (40) comprenant :
un circuit logique programmable FPGA (41),
une mémoire externe au circuit logique programmable FPGA (44),
un accélérateur matériel d’un réseau de neurones :
o entièrement implémenté sur le circuit logique programmable FPGA (41), o spécifiquement dédié au réseau de neurones de manière à être représentatif de l’ensemble de l’architecture du réseau neurones sans nécessiter d’accès à une mémoire externe (44) au circuit logique programmable FPGA lors du passage d’une couche (71 à 75) à une autre couche (72 à 76) du réseau de neurones,
o comprenant :
■ une interface (45) vers la mémoire externe,
■ une interface (49) vers l’extérieur de la carte électronique,
■ un noyau d’accélération (42) comprenant successivement :
• un bloc de lecture (50) d’information,
• un bloc de sérialisation (60) d’information avec deux voies (77, 78) de sortie, l’une (77) pour envoyer des données d’entrée aux couches (70-76) du réseau de neurones, l’autre (78) pour configurer des poids au niveau des couches (70-76) du réseau de neurones,
• les couches (70-76) du réseau de neurones,
• un bloc de désérialisation (80) d’information,
• un bloc d’écriture (90) d’information.
12. Carte électronique selon la revendication 11, caractérisée en ce que le bloc de lecture (50) d’information comprend une mémoire tampon (55), et le bloc d’écriture (90) d’information comprend une mémoire tampon (95).
13. Appareil embarqué comprenant une carte électronique selon la revendication 11 ou selon la revendication 12.
14. Appareil embarqué selon la revendication 13, caractérisé en ce qu’il est un appareil embarqué de vision par ordinateur.
PCT/FR2020/050822 2019-05-28 2020-05-18 Procede d'implementation d'un accelerateur materiel d'un reseau de neurones WO2020240113A1 (fr)

Priority Applications (2)

Application Number Priority Date Filing Date Title
EP20737247.5A EP3977363A1 (fr) 2019-05-28 2020-05-18 Procede d'implementation d'un accelerateur materiel d'un reseau de neurones
US17/614,081 US20230004775A1 (en) 2019-05-28 2020-05-18 Method for implementing a hardware accelerator of a neural network

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
FR1905681A FR3096811B1 (fr) 2019-05-28 2019-05-28 Procede d’implementation d’un accelerateur materiel d’un reseau de neurones
FR1905681 2019-05-28

Publications (1)

Publication Number Publication Date
WO2020240113A1 true WO2020240113A1 (fr) 2020-12-03

Family

ID=68138360

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/FR2020/050822 WO2020240113A1 (fr) 2019-05-28 2020-05-18 Procede d'implementation d'un accelerateur materiel d'un reseau de neurones

Country Status (4)

Country Link
US (1) US20230004775A1 (fr)
EP (1) EP3977363A1 (fr)
FR (1) FR3096811B1 (fr)
WO (1) WO2020240113A1 (fr)

Cited By (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN112925741A (zh) * 2021-03-29 2021-06-08 上海西井信息科技有限公司 异构计算方法和系统
CN112949847A (zh) * 2021-03-29 2021-06-11 上海西井信息科技有限公司 神经网络算法加速系统、调度系统及调度方法
CN113033784A (zh) * 2021-04-18 2021-06-25 沈阳雅译网络技术有限公司 一种针对cpu和gpu设备搜索神经网络结构的方法
CN113313243A (zh) * 2021-06-11 2021-08-27 海宁奕斯伟集成电路设计有限公司 神经网络加速器的确定方法、装置、设备以及存储介质

Families Citing this family (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
TWI778537B (zh) * 2021-03-05 2022-09-21 國立臺灣科技大學 神經網路加速單元的動態設計方法
CN113011569B (zh) * 2021-04-07 2024-06-18 开放智能机器（上海）有限公司 离线量化参数加注方法、装置、电子设备和存储介质
CN116301920B (zh) * 2023-03-23 2023-11-07 东北大学 一种用于部署cnn模型至基于fpga的高性能加速器的编译系统

Non-Patent Citations (4)

* Cited by examiner, † Cited by third party
Title
KAMEL ABDELOUAHAB ET AL: "Hardware Automated Dataflow Deployment of CNNs", ARXIV.ORG, CORNELL UNIVERSITY LIBRARY, 201 OLIN LIBRARY CORNELL UNIVERSITY ITHACA, NY 14853, 4 May 2017 (2017-05-04), XP081277400 *
KAMEL ABDELOUAHAB ET AL: "Tactics to Directly Map CNN graphs on Embedded FPGAs", ARXIV.ORG, CORNELL UNIVERSITY LIBRARY, 201 OLIN LIBRARY CORNELL UNIVERSITY ITHACA, NY 14853, 20 November 2017 (2017-11-20), XP081298963, DOI: 10.1109/LES.2017.2743247 *
KAMEL ABDELOUAHAB: "GitHub - KamelAbdelouahab/haddoc2: Caffe to VHDL - by DREAM research group", 12 June 2018 (2018-06-12), XP055668171, Retrieved from the Internet <URL:https://web.archive.org/web/20180612223706/https://github.com/KamelAbdelouahab/haddoc2> [retrieved on 20200213] *
UG973: "Vivado Design Suite User Guide Release Notes, Installation, and Licensing", 30 November 2016 (2016-11-30), XP055668207, Retrieved from the Internet <URL:https://www.xilinx.com/support/documentation/sw_manuals/xilinx2016_4/ug973-vivado-release-notes-install-license.pdf> [retrieved on 20200213] *

Cited By (7)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN112925741A (zh) * 2021-03-29 2021-06-08 上海西井信息科技有限公司 异构计算方法和系统
CN112949847A (zh) * 2021-03-29 2021-06-11 上海西井信息科技有限公司 神经网络算法加速系统、调度系统及调度方法
CN112925741B (zh) * 2021-03-29 2023-01-24 上海西井信息科技有限公司 异构计算方法和系统
CN112949847B (zh) * 2021-03-29 2023-07-25 上海西井科技股份有限公司 神经网络算法加速系统、调度系统及调度方法
CN113033784A (zh) * 2021-04-18 2021-06-25 沈阳雅译网络技术有限公司 一种针对cpu和gpu设备搜索神经网络结构的方法
CN113313243A (zh) * 2021-06-11 2021-08-27 海宁奕斯伟集成电路设计有限公司 神经网络加速器的确定方法、装置、设备以及存储介质
CN113313243B (zh) * 2021-06-11 2023-06-06 海宁奕斯伟集成电路设计有限公司 神经网络加速器的确定方法、装置、设备以及存储介质

Also Published As

Publication number Publication date
US20230004775A1 (en) 2023-01-05
EP3977363A1 (fr) 2022-04-06
FR3096811A1 (fr) 2020-12-04
FR3096811B1 (fr) 2022-07-29

Similar Documents

Publication Publication Date Title
WO2020240113A1 (fr) Procede d&#39;implementation d&#39;un accelerateur materiel d&#39;un reseau de neurones
Feng et al. Computer vision algorithms and hardware implementations: A survey
US11928590B2 (en) Methods and systems for power management in a pattern recognition processing system
US11003515B2 (en) Programmable device, hierarchical parallel machines, and methods for providing state information
US10783688B2 (en) Methods and arrangements to create images
CN108268940B (zh) 用于创建可重新配置的互连框架的工具
TW202026858A (zh) 在深度神經網路中利用啟動稀疏性
US20200410337A1 (en) Dynamic processing element array expansion
CN108764466B (zh) 基于现场可编程门阵列的卷积神经网络硬件及其加速方法
JP6859332B2 (ja) 選択的バックプロパゲーション
CN112580720B (zh) 一种模型训练方法及装置
CN108205707A (zh) 生成深度神经网络的方法、装置和计算机可读存储介质
WO2014014710A1 (fr) Procédés et systèmes pour utiliser des données de vecteur d&#39;états dans un moteur de machine d&#39;états
US11789711B2 (en) Using artificial intelligence to optimize software to run on heterogeneous computing resource
KR20230088714A (ko) 개인화된 뉴럴 네트워크 프루닝
WO2001063557A2 (fr) Procede et dispositif de perception automatique
KR20230078655A (ko) 에너지 효율적인 딥 러닝을 위한 동적 양자화
CN114881217A (zh) 一种基于fpga的通用型卷积神经网络加速器及其系统
CN116401552A (zh) 一种分类模型的训练方法及相关装置
WO2022207573A1 (fr) Autoencodeur multimodal a fusion de donnees latente amelioree
EP2956874B1 (fr) Dispositif et procédé pour accélérer la phase de mise à jour d&#39;un noyau de simulation
WO2018197693A1 (fr) Procédé et dispositif automatisés aptes à assurer l&#39;invariance perceptive d&#39;un évènement spatio-temporel dynamiquement en vue d&#39;en extraire des représentations sémantiques unifiées
CN116047330A (zh) 一种电池性能的预测方法、模型训练方法及相关装置
CN111914867A (zh) 一种基于fpga的卷积神经网络ip核设计
WO2023059723A1 (fr) Compression de modèle par analyse en composantes principales parcimonieuse quantifiée

Legal Events

Date Code Title Description
121 Ep: the epo has been informed by wipo that ep was designated in this application

Ref document number: 20737247

Country of ref document: EP

Kind code of ref document: A1

NENP Non-entry into the national phase

Ref country code: DE

ENP Entry into the national phase

Ref document number: 2020737247

Country of ref document: EP

Effective date: 20220103