EIE: Efficient Inference Engine on Compressed Deep Neural Network
Abstract
Stateoftheart deep neural networks (DNNs) have hundreds of millions of connections and are both computationally and memory intensive, making them difficult to deploy on embedded systems with limited hardware resources and power budgets. While custom hardware helps the computation, fetching weights from DRAM is two orders of magnitude more expensive than ALU operations, and dominates the required power.
Previously proposed ‘Deep Compression’ makes it possible to fit large DNNs (AlexNet and VGGNet) fully in onchip SRAM. This compression is achieved by pruning the redundant connections and having multiple connections share the same weight. We propose an energy efficient inference engine (EIE) that performs inference on this compressed network model and accelerates the resulting sparse matrixvector multiplication with weight sharing. Going from DRAM to SRAM gives EIE 120 energy saving; Exploiting sparsity saves 10; Weight sharing gives 8; Skipping zero activations from ReLU saves another 3. Evaluated on nine DNN benchmarks, EIE is 189 and 13 faster when compared to CPU and GPU implementations of the same DNN without compression. EIE has a processing power of 102 GOPS/s working directly on a compressed network, corresponding to 3 TOPS/s on an uncompressed network, and processes FC layers of AlexNet at 1.8810^{4} frames/sec with a power dissipation of only 600mW. It is 24,000 and 3,400 more energy efficient than a CPU and GPU respectively. Compared with DaDianNao, EIE has 2.9, 19 and 3 better throughput, energy efficiency and area efficiency.
I Introduction
Neural networks have become ubiquitous in applications including computer vision [1, 2, 3], speech recognition [4], and natural language processing [4]. In 1998, Lecun et al. classified handwritten digits with less than 1M parameters [5], while in 2012, Krizhevsky et al. won the ImageNet competition with 60M parameters [1]. Deepface classified human faces with 120M parameters [6]. Neural Talk [7] automatically converts image to natural language with 130M CNN parameters and 100M RNN parameters. Coates et al. scaled up a network to 10 billion parameters on HPC systems [8].
Large DNN models are very powerful but consume large amounts of energy because the model must be stored in external DRAM, and fetched every time for each image, word, or speech sample. For embedded mobile applications, these resource demands become prohibitive. Table I shows the energy cost of basic arithmetic and memory operations in a 45nm CMOS process [9]. It shows that the total energy is dominated by the required memory access if there is no data reuse. The energy cost per fetch ranges from 5pJ for 32b coefficients in onchip SRAM to 640pJ for 32b coefficients in offchip LPDDR2 DRAM. Large networks do not fit in onchip storage and hence require the more costly DRAM accesses. Running a 1G connection neural network, for example, at 20Hz would require just for DRAM accesses, which is well beyond the power envelope of a typical mobile device.
Previous work has used specialized hardware to accelerate DNNs [10, 11, 12]. However, these efforts focus on accelerating dense, uncompressed models  limiting their utility to small models or to cases where the high energy cost of external DRAM access can be tolerated. Without model compression, it is only possible to fit very small neural networks, such as Lenet5, in onchip SRAM [12].
Efficient implementation of convolutional layers in CNN has been intensively studied, as its data reuse and manipulation is quite suitable for customized hardware [10, 11, 12, 13, 14, 15]. However, it has been found that fullyconnected (FC) layers, widely used in RNN and LSTMs, are bandwidth limited on large networks [14]. Unlike CONV layers, there is no parameter reuse in FC layers. Data batching has become an efficient solution when training networks on CPUs or GPUs, however, it is unsuitable for realtime applications with latency requirements.
Operation  Energy [pJ]  Relative Cost 

32 bit int ADD  0.1  1 
32 bit float ADD  0.9  9 
32 bit int MULT  3.1  31 
32 bit float MULT  3.7  37 
32 bit 32KB SRAM  5  50 
32 bit DRAM  640  6400 
Network compression via pruning and weight sharing [16] makes it possible to fit modern networks such as AlexNet (60M parameters, 240MB), and VGG16 (130M parameters, 520MB) in onchip SRAM. Processing these compressed models, however, is challenging. With pruning, the matrix becomes sparse and the indicies become relative. With weight sharing, we store only a short (4bit) index for each weight. This adds extra levels of indirection that cause complexity and inefficiency on CPUs and GPUs.
To efficiently operate on compressed DNN models, we propose EIE, an efficient inference engine, a specialized accelerator that performs customized sparse matrix vector multiplication and handles weight sharing with no loss of efficiency. EIE is a scalable array of processing elements (PEs) Every PE stores a partition of network in SRAM and performs the computations associated with that part. It takes advantage of dynamic input vector sparsity, static weight sparsity, relative indexing, weight sharing and extremely narrow weights (4bits).
In our design, each PE holds 131K weights of the compressed model, corresponding to 1.2M weights of the original dense model, and is able to perform 800 million weight calculations per second. In 45nm CMOS technology, an EIE PE has an area of 0.638mm and dissipates 9.16mW at 800MHz. The fullyconnected layers of AlexNet fit into 64PEs that consume a total of 40.8mm and operate at frames/sec with a power dissipation of 590mW. Compared with CPU (Intel i75930k) GPU (GeForce TITAN X) and mobile GPU (Tegra K1), EIE achieves , and acceleration, while saving , and energy, respectively.
This paper makes the following contributions:

We present the first accelerator for sparse and weight sharing neural networks. Operating directly on compressed networks enables the large neural network models to fit in onchip SRAM, which results in better energy savings compared to accessing from external DRAM.

EIE is the first accelerator that exploits the dynamic sparsity of activations to save computation. EIE saves 65.16% energy by avoiding weight references and arithmetic for the 70% of activations that are zero in a typical deep learning applications.

We describe a method of both distributed storage and distributed computation to parallelize a sparsified layer across multiple PEs, which achieves load balance and good scalability.

We evaluate EIE on a wide range of deep learning models, including CNN for object detection and LSTM for natural language processing and image captioning. We also compare EIE to CPU, GPU, FPGA, and other ASIC accelerators.
In Section II we describe the motivation of accelerating compressed networks. Section III reviews the compression technique that EIE uses and how to parallelize the workload. The hardware architecture in each PE to perform inference is described in Section IV. In Section V we describe our evaluation methodology. Then we report our experimental results in Section VI, followed by discussions, comparison with related work and conclusions.
Ii Motivation
Matrixvector multiplication (MV) is a basic building block in a wide range of neural networks and deep learning applications. In convolutional neural network (CNN), fully connected layers are implemented with MV, and more than 96% of the connections are in the FC layers [1]. In object detection algorithms, an FC layer is required to run multiple times on all proposal regions, taking up to computation time [17]. In recurrent neural network (RNN), MV operations are performed on the new input and the hidden state at each time step, producing a new hidden state and the output. LongShortTermMemory (LSTM) [18] is a widely used structure of RNN cell that provides more complex hidden unit computation. Each LSTM cell can be decomposed into eight MV operations, two for each: input gate, forget gate, output gate, and one temporary memory cell. RNN, including LSTM, is widely used in image captioning [7], speech recognition [19] and natural language processing [4].
During MV, the memory access is usually the bottleneck [14] especially when the matrix is larger than the cache capacity. There is no reuse of the input matrix, thus a memory access is needed for every operation. On CPUs and GPUs, this problem is usually solved by batching, i.e., combining multiple vectors into a matrix to reuse the parameters. However, such a strategy is unsuitable for realtime applications that are latencysensitive, such as pedestrian detection in an autonomous vehicle[20], because batching substantially increases latency. Therefore it is preferable to create an efficient method of executing large neural networks without the latency cost of batching.
Because memory access is the bottleneck in large layers, compressing the neural network offers a solution. Though compression reduces the total number of operations, the irregular pattern caused by compression hinders the effective acceleration on CPUs and GPUs, as illustrated in Table IV.
A compressed network is not efficient on previous accelerators either. Previous SPMV accelerators can only exploit the static weight sparsity. They are unable to exploit dynamic activation sparsity[21]. Previous DNN accelerators cannot exploit either form of sparsity and must expand the network to dense form before operation[11]. Neither is able to exploit weight sharing. This motivates building a special engine that can operate on a compressed network.
Iii DNN Compression and Parallelization
Iiia Computation
A FC layer of a DNN performs the computation
(1) 
Where is the input activation vector, is the output activation vector, is the bias, is the weight matrix, and is the nonlinear function, typically the Rectified Linear Unit(ReLU)[22] in CNN and some RNN. Sometimes will be combined with by appending an additional one to vector , therefore we neglect the bias in the following paragraphs.
For a typical FC layer like FC7 of VGG16 or AlexNet, the activation vectors are 4K long, and the weight matrix is 4K 4K (16M weights). Weights are represented as singleprecision floatingpoint numbers so such a layer requires 64MB of storage. The output activations of Equation (1) are computed elementwise as:
(2) 
Deep Compression [23] describes a method to compress DNNs without loss of accuracy through a combination of pruning and weight sharing. Pruning makes matrix sparse with density ranging from 4% to 25% for our benchmark layers. Weight sharing replaces each weight with a fourbit index into a shared table of 16 possible weight values.
With deep compression, the peractivation computation of Equation (2) becomes
(3) 
Where is the set of columns for which , is the set of indices for which , is the index to the shared weight that replaces , and is the table of shared weights. Here represents the static sparsity of and represents the dynamic sparsity of . The set is fixed for a given model. The set varies from input to input.
Accelerating Equation (3) is needed to accelerate a compressed DNN. We perform the indexing and the multiplyadd only for those columns for which both and are nonzero, so that both the sparsity of the matrix and the vector are exploited. This results in a dynamically irregular computation. Performing the indexing itself involves bit manipulations to extract fourbit and an extra load (which is almost assured a cache hit).
IiiB Representation
To exploit the sparsity of activations we store our encoded sparse weight matrix in a variation of compressed sparse column (CSC) format [24].
For each column of matrix we store a vector that contains the nonzero weights, and a second, equallength vector that encodes the number of zeros before the corresponding entry in . Each entry of and is represented by a fourbit value. If more than 15 zeros appear before a nonzero entry we add a zero in vector . For example, we encode the following column
as , . and of all columns are stored in one large pair of arrays with a pointer vector pointing to the beginning of the vector for each column. A final entry in points one beyond the last vector element so that the number of nonzeros in column (including padded zeros) is given by .
Storing the sparse matrix by columns in CSC format makes it easy to exploit activation sparsity. We simply multiply each nonzero activation by all of the nonzero elements in its corresponding column.
IiiC Parallelizing Compressed DNN
We distribute the matrix and parallelize our matrixvector computation by interleaving the rows of the matrix over multiple processing elements (PEs). With PEs, PE holds all rows , output activations , and input activations for which . The portion of column in PE is stored in the CSC format described in Section IIIB but with the zero counts referring only to zeros in the subset of the column in this PE. Each PE has its own , , and arrays that encode its fraction of the sparse matrix.
Figure 2 shows an example multiplying an input activation vector (of length 8) by a weight matrix yielding an output activation vector (of length 16) on PEs. The elements of , , and are color coded with their PE assignments. Each PE owns 4 rows of , 2 elements of , and 4 elements of .
We perform the sparse matrix sparse vector operation by scanning vector to find its next nonzero value and broadcasting along with its index to all PEs. Each PE then multiplies by the nonzero elements in its portion of column — accumulating the partial sums in accumulators for each element of the output activation vector . In the CSC representation these nonzeros weights are stored contiguously so each PE simply walks through its array from location to to load the weights. To address the output accumulators, the row number corresponding to each weight is generated by keeping a running sum of the entries of the array.
In the example of Figure 2, the first nonzero is on . The value and its column index is broadcast to all PEs. Each PE then multiplies by every nonzero in its portion of column 2. multiplies by and ; has all zeros in column 2 and so performs no multiplications; multiplies by and , and so on. The result of each product is summed into the corresponding row accumulator. For example computes and . The accumulators are initialized to zero before each layer computation.
The interleaved CSC representation facilitates exploitation of both the dynamic sparsity of activation vector and the static sparsity of the weight matrix . We exploit activation sparsity by broadcasting only nonzero elements of input activation . Columns corresponding to zeros in are completely skipped. The interleaved CSC representation allows each PE to quickly find the nonzeros in each column to be multiplied by . This organization also keeps all of the computation except for the broadcast of the input activations local to a PE. The interleaved CSC representation of matrix in Figure 2 is shown in Figure 3.
This process may suffer load imbalance because each PE may have a different number of nonzeros in a particular column. We will see in Section IV how this load imbalance can be reduced by queuing.
Iv Hardware Implementation
Figure 4 shows the architecture of EIE. A Central Control Unit (CCU) controls an array of PEs that each computes one slice of the compressed network. The CCU also receives nonzero input activations from a distributed leading nonzero detection network and broadcasts these to the PEs.
Almost all computation in EIE is local to the PEs except for the collection of nonzero input activations that are broadcast to all PEs. However, the timing of the activation collection and broadcast is noncritical as most PEs take many cycles to consume each input activation.
Activation Queue and Load Balancing. Nonzero elements of the input activation vector and their corresponding index are broadcast by the CCU to an activation queue in each PE. The broadcast is disabled if any PE has a full queue. At any point in time each PE processes the activation at the head of its queue.
The activation queue allows each PE to build up a backlog of work to even out load imbalance that may arise because the number of non zeros in a given column may vary from PE to PE. In Section VI we measure the sensitivity of performance to the depth of the activation queue.
Pointer Read Unit. The index of the entry at the head of the activation queue is used to look up the start and end pointers and for the and arrays for column . To allow both pointers to be read in one cycle using singleported SRAM arrays, we store pointers in two SRAM banks and use the LSB of the address to select between banks. and will always be in different banks. EIE pointers are 16bits in length.
Sparse Matrix Read Unit. The sparsematrix read unit uses pointers and to read the nonzero elements (if any) of this PE’s slice of column from the sparsematrix SRAM. Each entry in the SRAM is 8bits in length and contains one 4bit element of and one 4bit element of .
For efficiency (see Section VI) the PE’s slice of encoded sparse matrix is stored in a 64bitwide SRAM. Thus eight entries are fetched on each SRAM read. The high 13 bits of the current pointer selects an SRAM row, and the low 3bits select one of the eight entries in that row. A single entry is provided to the arithmetic unit each cycle.
Arithmetic Unit. The arithmetic unit receives a entry from the sparse matrix read unit and performs the multiplyaccumulate operation . Index is used to index an accumulator array (the destination activation registers) while is multiplied by the activation value at the head of the activation queue. Because is stored in 4bit encoded form, it is first expanded to a 16bit fixedpoint number via a table look up. A bypass path is provided to route the output of the adder to its input if the same accumulator is selected on two adjacent cycles.
Activation Read/Write. The Activation Read/Write Unit contains two activation register files that accommodate the source and destination activation values respectively during a single round of FC layer computation. The source and destination register files exchange their role for next layer. Thus no additional data transfer is needed to support multilayer feedforward computation.
Each activation register file holds 64 16bit activations. This is sufficient to accommodate 4K activation vectors across 64 PEs. Longer activation vectors can be accommodated with the 2KB activation SRAM. When the activation vector has a length greater than 4K, the MV will be completed in several batches, where each batch is of length 4K or less. All the local reduction is done in the register file. The SRAM is read only at the beginning and written at the end of the batch.
Distributed Leading NonZero Detection. Input activations are hierarchically distributed to each PE. To take advantage of the input vector sparsity, we use leading nonzero detection logic to select the first nonzero result. Each group of 4 PEs does a local leading nonzero detection on their input activation. The result is sent to a Leading Nonzero Detection Node (LNZD Node) illustrated in Figure 4. Each LNZD node finds the next nonzero activation across its four children and sends this result up the quadtree. The quadtree is arranged so that wire lengths remain constant as we add PEs. At the root LNZD Node, the selected nonzero activation is broadcast back to all the PEs via a separate wire placed in an Htree.
Central Control Unit. The Central Control Unit (CCU) is the root LNZD Node. It communicates with the master, for example a CPU, and monitors the state of every PE by setting the control registers. There are two modes in the Central Unit: I/O and Computing. In the I/O mode, all of the PEs are idle while the activations and weights in every PE can be accessed by a DMA connected with the Central Unit. This is one time cost. In the Computing mode, the CCU repeatedly collects a nonzero value from the LNZD quadtree and broadcasts this value to all PEs. This process continues until the input length is exceeded. By setting the input length and starting address of pointer array, EIE is instructed to execute different layers.
Power  (%)  Area  (%)  
(mW)  ()  
Total  9.157  638,024  
memory  5.416  (59.15%)  594,786  (93.22%) 
clock network  1.874  (20.46%)  866  (0.14%) 
register  1.026  (11.20%)  9,465  (1.48%) 
combinational  0.841  (9.18%)  8,946  (1.40%) 
filler cell  23,961  (3.76%)  
Act_queue  0.112  (1.23%)  758  (0.12%) 
PtrRead  1.807  (19.73%)  121,849  (19.10%) 
SpmatRead  4.955  (54.11%)  469,412  (73.57%) 
ArithmUnit  1.162  (12.68%)  3,110  (0.49%) 
ActRW  1.122  (12.25%)  18,934  (2.97%) 
filler cell  23,961  (3.76%) 
V Evaluation Methodology
Simulator, RTL and Layout. We implemented a custom cycleaccurate C++ simulator for the accelerator aimed to model the RTL behavior of synchronous circuits. Each hardware module is abstracted as an object that implements two abstract methods: propagate and update, corresponding to combination logic and the flipflop in RTL. The simulator is used for design space exploration. It also serves as a checker for RTL verification.
To measure the area, power and critical path delay, we implemented the RTL of EIE in Verilog. The RTL is verified against the cycleaccurate simulator. Then we synthesized EIE using the Synopsys Design Compiler (DC) under the TSMC 45nm GP standard VT library with worst case PVT corner. We placed and routed the PE using the Synopsys IC compiler (ICC). We used Cacti [25] to get SRAM area and energy numbers. We annotated the toggle rate from the RTL simulation to the gatelevel netlist, which was dumped to switching activity interchange format (SAIF), and estimated the power using PrimeTime PX.
Comparison Baseline. We compare EIE with three different offtheshelf computing units: CPU, GPU and mobile GPU.
1) CPU. We use Intel Core i7 5930k CPU, a HaswellE class processor, that has been used in NVIDIA Digits Deep Learning Dev Box as a CPU baseline. To run the benchmark on CPU, we used MKL CBLAS GEMV to implement the original dense model and MKL SPBLAS CSRMV for the compressed sparse model. CPU socket and DRAM power are as reported by the pcmpower utility provided by Intel.
2) GPU. We use NVIDIA GeForce GTX Titan X GPU, a stateoftheart GPU for deep learning as our baseline using nvidiasmi utility to report the power. To run the benchmark, we used cuBLAS GEMV to implement the original dense layer. For the compressed sparse layer, we stored the sparse matrix in in CSR format, and used cuSPARSE CSRMV kernel, which is optimized for sparse matrixvector multiplication on GPUs.
3) Mobile GPU. We use NVIDIA Tegra K1 that has 192 CUDA cores as our mobile GPU baseline. We used cuBLAS GEMV for the original dense model and cuSPARSE CSRMV for the compressed sparse model. Tegra K1 doesn’t have software interface to report power consumption, so we measured the total power consumption with a powermeter, then assumed AC to DC conversion loss, regulator efficiency and power consumed by peripheral components [26, 27] to report the AP+DRAM power for Tegra K1.
Layer  Size  Weight%  Act%  FLOP%  Description 

Alex6  9216,  9%  35.1%  3%  Compressed 
4096  AlexNet [1] for  
Alex7  4096,  9%  35.3%  3%  large scale image 
4096  classification  
Alex8  4096,  25%  37.5%  10%  
1000  
VGG6  25088,  4%  18.3%  1%  Compressed 
4096  VGG16 [3] for  
VGG7  4096,  4%  37.5%  2%  large scale image 
4096  classification and  
VGG8  4096,  23%  41.1%  9%  object detection 
1000  
NTWe  4096,  10%  100%  10%  Compressed 
600  NeuralTalk [7]  
NTWd  600,  11%  100%  11%  with RNN and 
8791  LSTM for  
NTLSTM  1201,  10%  100%  11%  automatic 
2400  image captioning 
Platform  Batch  Matrix  AlexNet  VGG16  NT  

Size  Type  FC6  FC7  FC8  FC6  FC7  FC8  We  Wd  LSTM  
CPU  1  dense  7516.2  6187.1  1134.9  35022.8  5372.8  774.2  605.0  1361.4  470.5 
(Core  sparse  3066.5  1282.1  890.5  3774.3  545.1  777.3  261.2  437.4  260.0  
i75930k)  64  dense  318.4  188.9  45.8  1056.0  188.3  45.7  28.7  69.0  28.8 
sparse  1417.6  682.1  407.7  1780.3  274.9  363.1  117.7  176.4  107.4  
GPU  1  dense  541.5  243.0  80.5  1467.8  243.0  80.5  65  90.1  51.9 
(Titan X)  sparse  134.8  65.8  54.6  167.0  39.8  48.0  17.7  41.1  18.5  
64  dense  19.8  8.9  5.9  53.6  8.9  5.9  3.2  2.3  2.5  
sparse  94.6  51.5  23.2  121.5  24.4  22.0  10.9  11.0  9.0  
mGPU  1  dense  12437.2  5765.0  2252.1  35427.0  5544.3  2243.1  1316  2565.5  956.9 
(Tegra K1)  sparse  2879.3  1256.5  837.0  4377.2  626.3  745.1  240.6  570.6  315  
64  dense  1663.6  2056.8  298.0  2001.4  2050.7  483.9  87.8  956.3  95.2  
sparse  4003.9  1372.8  576.7  8024.8  660.2  544.1  236.3  187.7  186.5  
EIE  Theoretical Time  28.1  11.7  8.9  28.1  7.9  7.3  5.2  13.0  6.5  
Actual Time  30.3  12.2  9.9  34.4  8.7  8.4  8.0  13.9  7.5 
Benchmarks. We compare the performance on two sets of models: uncompressed DNN model and the compressed DNN model. The uncompressed DNN model is obtained from Caffe model zoo [28] and NeuralTalk model zoo [7]; The compressed DNN model is produced as described in [23, 16]. The benchmark networks have 9 layers in total obtained from AlexNet, VGGNet, and NeuralTalk. We use the ImageNet dataset [29] and the Caffe [28] deep learning framework as golden model to verify the correctness of the hardware design.
Vi Experimental Results
Figure 5 shows the layout (after placeandroute) of an EIE processing element. The power/area breakdown is shown in Table II. We brought the critical path delay down to 1.15ns by introducing 4 pipeline stages to update one activation: codebook lookup and address accumulation (in parallel), output activation read and input activation multiply (in parallel), shift and add, and output activation write. Activation read and write access a local register and activation bypassing is employed to avoid a pipeline hazard. Using 64 PEs running at 800MHz yields a performance of 102 GOP/s. Considering weight sparsity and activation sparsity, this requires a dense DNN accelerator 3TOP/s to have equivalent application throughput.
The total SRAM capacity (Spmat+Ptr+Act) of each EIE PE is 162KB. The activation SRAM is 2KB storing activations. The Spmat SRAM is 128KB storing the compressed weights and indices. Each weight is 4bits, each index is 4bits. Weights and indices are grouped to 8bits and addressed together. The Spmat access width is optimized at 64bits. The Ptr SRAM is 32KB storing the pointers in the CSC format. In the steady state, both Spmat SRAM and Ptr SRAM are accessed every cycles. The area and power is dominated by SRAM, the ratio is 93% and 59% respectively. Each PE is consuming . Each group of 4 PEs needs a LNZD unit for nonzero detection. A total of 21 LNZD units are needed for 64 PEs (). Synthesized result shows that one LNZD unit takes only and an area of , less than 0.3 of a PE.
Via Performance
We compare EIE against CPU, desktop GPU and the mobile GPU on 9 benchmarks selected from AlexNet, VGG16 and Neural Talk. The overall results are shown in Figure 6. There are 7 columns for each benchmark, comparing the computation time of EIE on compressed network over CPU / GPU / TK1 on uncompressed / compressed network. Time is normalized to CPU. EIE significantly outperforms the general purpose hardware and is, on average, 189, 13, 307 faster than CPU, GPU and mobile GPU respectively.
EIE’s theoretical computation time is calculated by dividing workload GOPs by peak throughput. The actual computation time is around 10% more than the theoretical computation time due to load imbalance. In Fig. 6, the comparison with CPU / GPU / TK1 is reported using actual computation time. The wall clock time of CPU / GPU / TK1/ EIE for all benchmarks are shown in Table IV.
EIE is targeting extremely latencyfocused applications, which require realtime inference. Since assembling a batch adds significant amounts of latency, we consider the case when batch size = 1 when benchmarking the performance and energy efficiency with CPU and GPU as shown in Figure 6. As a comparison, we also provided the result for batch size = 64 in Table IV. EIE outperforms most of the platforms and is comparable to desktop GPU in the batching case.
The GOP/s required for EIE to achieve the same application throughput (Frames/s) is much lower than competing approaches because EIE exploits sparsity to eliminate 97% of the GOP/s performed by dense approaches. 3 TOP/s on an uncompressed network requires only 100 GOP/s on a compressed network. EIE’s throughput is scalable to over 256 PEs. Without EIE’s dedicated logic, however, model compression by itself applied on a CPU/GPU yields only speedup.
ViB Energy
In Figure 7, we report the energy efficiency comparisons of MV on different benchmarks. There are 7 columns for each benchmark, comparing the energy efficiency of EIE on compressed network over CPU / GPU / TK1 on uncompressed / compressed network. Energy is obtained by multiplying computation time and total measured power as described in section V.
EIE consumes on average, , , and less energy compared to CPU, GPU and the mobile GPU respectively. This is a 3order of magnitude energy saving from three places: first, the required energy per memory read is saved (SRAM over DRAM): using a compressed network model enables stateoftheart neural networks to fit in onchip SRAM, reducing energy consumption by 120 compared to fetching a dense uncompressed model from DRAM (Figure 7). Second, the number of required memory reads is reduced. The compressed DNN model has 10% of the weights where each weight is quantized by only 4 bits. Lastly, taking advantage of vector sparsity saved 65.14% redundant computation cycles. Multiplying those factors gives theoretical energy saving. Our actual savings are about less than this number because of index overhead and because EIE is implemented in 45nm technology compared to the 28nm technology used by the TitanX GPU and the Tegra K1 mobile GPU.
ViC Design Space Exploration
Queue Depth. The activation FIFO queue deals with load imbalance between the PEs. A deeper FIFO queue can better decouple producer and consumer, but with diminishing returns, as shown in our experiment in Figure 8. We varied the FIFO queue depth from from 1 to 256 in powers of 2 across 9 benchmarks using 64 PEs, and measured the load balance efficiency. This efficiency is defined as: 1 bubble cycles (due to starvation) divided by total computation cycles. At FIFO size 1, around half of the total cycles are idle and the accelerator suffers from severe load imbalance. Load imbalance is reduced as FIFO depth is increased but with diminishing returns beyond a depth of 8. Thus, we choose 8 as the optimal queue depth.
Notice the NTWe benchmark has poorer load balance efficiency compared with others. This is because that it has only 600 rows. Divided by 64 PEs and considering the 11% sparsity, each PE on average gets a single entry, which is highly susceptible to variation among PEs, leading to load imbalance. Such small matrices are more efficiently executed on 32 or fewer PEs.
SRAM Width. We choose an SRAM with a 64bit interface to store the sparse matrix (Spmat) since it minimized the total energy. Wider SRAM interfaces reduce the number of total SRAM accesses, but increase the energy cost per SRAM read. The experimental tradeoff is shown in Figure 9. SRAM energy is modeled using Cacti [25] under 45nm process. SRAM access times are measured by the cycleaccurate simulator on AlexNet benchmark. As the total energy is shown on the right, the minimum total access energy is achieved when SRAM width is 64 bits. For larger SRAM widths, read data is wasted: the typical number of activation elements of FC layer is 4K[1, 3] so assuming 64 PEs and 10% density [16], each column in a PE will have 6.4 elements on average. This matches a 64bit SRAM interface that provides 8 elements. If more elements are fetched and the next column corresponds to a zero activation, those elements are wasted.
Arithmetic Precision. We use 16bit fixedpoint arithmetic. As shown in Figure 10, 16bit fixedpoint multiplication consumes less energy than 32bit fixedpoint and less energy than 32bit floatingpoint. At the same time, using 16bit fixedpoint arithmetic results in less than 0.5% loss of prediction accuracy: 79.8% compared with 80.3% using 32bit floating point arithmetic. With 8bits fixedpoint, however, the accuracy dropped to only 53%, which becomes intolerable. The accuracy is measured on ImageNet dataset [29] with AlexNet [1], and the energy is obtained from synthesized RTL under 45nm process.
‘Deep Compression’ does not affect accuracy[16][23][30], but using 16bit arithmetic degrades accuracy by only 0.5%. In order to have absolute no loss of accuracy, switching to 32 bit arithmetic would not substantially affect the power or area of EIE. Only the 16entry codebook, the arithmetic units, and the activation register files would change in width. The index stored in SRAM would remain 4bits. The majority of power/area is taken by SRAM, not arithmetic. The area used by filler cells (used to fill blank area) is sufficient to double the area of the arithmetic units and activation registers (Table II).
Vii Discussion
Many engines have been proposed for Sparse MatrixVector multiplication (SPMV) and the existing tradeoffs on the targeted platforms are studied [31, 21]. There are typically three approaches to partition the workload for matrixvector multiplication. The combination of these methods with storage format of the Matrix creates a design space tradeoff.
Viia Workload Partitioning
The first approach is to distribute matrix columns to PEs. Each PE handles the multiplication between its columns of and corresponding element of to get a partial sum of the output vector . The benefit of this solutions is that each element of is only associated with one PE — giving full locality for vector . The drawback is that a reduction operation between PEs is required to obtain the final result.
A second approach (ours) is to distribute matrix rows to PEs. A central unit broadcasts one vector element to all PEs. Each PE computes a number of output activations by performing inner products of the corresponding row of , that is stored in the PE with vector . The benefit of this solutions is that each element of is only associated with one PE — giving full locality for vector . The drawback is that vector needs to be broadcast to all PEs.
A third approach combines the previous two approaches by distributing blocks of to the PEs in 2D fashion. This solution is more scalable for distributed systems where communication latency cost is significant [32]. This way both of the collective communication operations ”Broadcast” and ”Reduction” are exploited but in a smaller scale and hence this solution is more scalable.
The nature of our target class of application and its sparsity pattern affects the constraints and therefore our choice of partitioning and storage. The density of is , and the density of is , both with random distribution. Vector is stored in normal dense format and contains the zeros in the memory, because for different input, ’s sparsity pattern differs. We want to utilize the sparsity of both and .
The first solution suffers from load imbalance given that vector is also sparse. Each PE is responsible for a column. PE will be completely idle if their corresponding element is zero. On top of the Idle PEs, this solution requires acrossPE reduction and extra level of synchronization.
Since the SPMV engine, has a limited number of PEs, there won’t be a scalability issue to worry about. However, the hybrid solution will suffer from inherent complexity and still possible load imbalance since multiple PEs sharing the same column might remain idle.
We build our solution based on the second distribution scheme taking the 30% density of vector into account. Our solution aims to perform computations by inorder lookup of nonzeros in . Each PE gets all the nonzero elements of in order and performs the inner products by lookingup the matching element that needs to be multiplied by , . This requires the matrix being stored in CSC format so the PE can multiply all the elements in the th column of by .
ViiB Scalability
As the matrix gets larger, the system can be scaled up by adding more PEs. Each PE has local SRAM storing distinct rows of the matrix without duplication, so the SRAM is efficiently utilized.
Wire delay increases with the square root of the number of PEs, however, this is not a problem in our architecture. Since EIE only requires one broadcast over the computation of the entire column, which takes many cycles. Consequently, the broadcast is not on the critical path and can be pipelined because FIFOs decouple producer and consumer.
Figure 11 shows EIE achieves good scalability on all benchmarks except NTWe. NTWe is very small (). Dividing the columns of size 600 and sparsity 10% to 64 or more PEs causes serious load imbalance.
Figure 12 shows the number of padding zeros with different number PEs. Padding zero occur when the jump between two consecutive nonzero element in the sparse matrix is larger than 16, the largest number that 4 bits can encode. Padding zeros are considered nonzero and lead to wasted computation. Using more PEs reduces padding zeros, because the distance between nonzero elements get smaller due to matrix partitioning, and 4bits encoding a max distance of 16 will more likely be enough.
ViiC Flexibility
EIE is designed for large neural networks. The weights and input/ouput of most layers can be easily fit into EIE’s storage. For those with extremely large input/output sizes (for example, FC6 layer of VGG16 has an input size of 25088), EIE is still able to execute them with 64PEs.
EIE can assist generalpurpose processors for sparse neural network acceleration or other tasks related to SPMV. One type of neural network structure can be decomposed into certain control sequence so that by writing control sequence to the registers of EIE, a network could be executed.
EIE has the potential to support 1x1 convolution and 3x3 Winograd convolution by turning the channelwise reduction into an . Winograd convolution saves multiplications than naive convolution[33], and for each Winograd patch the 16 can be scheduled on an EIE.
Viii Comparison with Related Work
We compare the results of performance, power and area on in Table V. The performance is evaluated on the FC7 layer of AlexNet^{1}^{1}1Except for TrueNorth where FC7 result is not provided, using TIMIT LSTM result for comparison instead (different benchmarks differ ).. We compared six platforms for neural networks: Corei7 (CPU), Titan X (GPU), Tegra K1 (mobile GPU), AEye (FPGA), DaDianNao (ASIC), TrueNorth (ASIC). All other four platforms suffer from lowefficiency during matrixvector multiplication. AEye is optimized for CONV layers and all of the parameters are fetched from the external DDR3 memory, making it extremely sensitive to bandwidth problem. DaDianNao distributes weights on 16 tiles, each tile with 4 eDRAM banks, thus has a peak memory bandwidth of . Its performance on is estimated based on the peak memory bandwidth because is completely memory bound. In contrast, EIE maintains a high throughput for because after compression, all weights fit in onchip SRAM, even for very largescale networks. With 256PEs, EIE has more throughput than 64PEs and can hold 336 million parameters, even larger than VGGnet. The right column projected EIE to the same technology (28nm) as the other platforms, with 256PEs, EIE has throughput, area efficiency and power efficiency than DaDianNao.
Model Compression. DNN model compression is widely used to reduce the storage required by DNN models. In early work, network pruning proved to be a promising approach to reducing the network complexity and overfitting [34, 35, 36]. Recently Han et al. [16] pruned connections in large scale neural networks and achieved and pruning rate for AlexNet and VGG16 with no loss of accuracy on ImageNet. The followup work ‘Deep Compression’ [23] compressed DNN by pruning, weight sharing and Huffman coding, pushing the compression ratio to 3549. SqueezeNet [30] further pushes this ratio to 510: it combines new ConvNet architecture and Deep Compression, its model size is only 470KB660KB and has the same prediction accuracy as AlexNet. SqueezeNet makes it easy to fit DNN model fully in SRAM and is available online^{2}^{2}2The 660KB version of SqueezeNet model trained on Imagenet is available at: http://songhan.github.io/SqueezeNetDeepCompression. SVD is frequently used to reduce model size [37][38]. Minerva [39] also uses data quantization to save memory energy.
Model compression is crucial for reducing memory energy. However, model compression by itself applied on a GPU yields only energy savings[23], while EIE increases this to by tailoring an architecture to exploit the irregularity and decoding created by model compression.
DNN accelerator. Many custom accelerators have been proposed for DNNs. DianNao [10] implements an array of multiplyadd units to map large DNN onto its core architecture. Due to limited SRAM resource, the offchip DRAM traffic dominates the energy consumption. DaDianNao [11] and ShiDianNao [12] eliminate the DRAM access by having all weights onchip (eDRAM or SRAM).
Platform  Corei7 5930K  GeForce Titan X  Tegra K1  AEye [14]  DaDianNao[11]  True North[40]  EIE (ours, 64PE)  EIE (28nm, 256PE) 

Year  2014  2015  2014  2015  2014  2014  2016  2016 
Platform Type  CPU  GPU  mGPU  FPGA  ASIC  ASIC  ASIC  ASIC 
Technology  22nm  28nm  28nm  28nm  28nm  28nm  45nm  28nm 
Clock (MHz)  3500  1075  852  150  606  Async  800  1200 
Memory type  DRAM  DRAM  DRAM  DRAM  eDRAM  SRAM  SRAM  SRAM 
Max DNN model size (#Params)  16G  3G  500M  500M  18M  256M  84M  336M 
Quantization Stategy  32bit float  32bit float  32bit float  16bit fixed  16bit fixed  1bit fixed  4bit fixed  4bit fixed 
Area (mm^{2})  356  601      67.7  430  40.8  63.8 
Power (W)  73  159  5.1  9.63  15.97  0.18  0.59  2.36 
MV Throughput (Frames/s)  162  4,115  173  33  147,938  1,989  81,967  426,230 
Area Efficiency ( Frames/s/mm^{2})  0.46  6.85      2,185  4.63  2,009  6,681 
Energy Efficiency (Frames/J)  2.22  25.9  33.9  3.43  9,263  10,839  138,927  180,606 
In both architectures, the weights are uncompressed and stored in the dense format. As a result, ShiDianNao can only handle very small DNN models up to 64K parameters, which is 3 orders of magnitude smaller than the 60 Million parameter AlexNet by only containing 128KB onchip RAM. Such large networks are impossible to fit on chip on ShiDianNao without compression.
DaDianNao stores the uncompressed model in eDRAM taking 6.12W memory power and 15.97W total power. EIE stores compressed model in SRAM taking only 0.35W memory power and only 0.59W total power; DaDianNao cannot exploit the sparsity from weights and activations and they must expand the network to dense form before operation. It can not exploit weight sharing either. Using just the compression (and decompressing the data before computation) would reduce DaDianNao total power to around 10W in 28nm, compared to EIEâs power of 0.58W in 45nm.
Previous DNN accelerators targeting ASIC and FPGA platforms [10][41] used mostly CONV layer as benchmarks, but have few dedicated experiments on FC layers, which has significant bandwidth bottlenecks, and is widely used in RNN and LSTMs. Loading weights from the external memory for the FC layer may significantly degrade the overall performance of the network[14].
Sparse MatrixVector Multiplication Accelerator. There is research effort on the implementation of sparse matrixvector multiplication (SPMV) on generalpurpose processors. Monakov et al. [42] proposed a matrix storage format that improves locality, which has low memory footprint and enables automatic parameter tuning on GPU. Bell et al. [43] implemented data structures and algorithms for SPMV on GeForce GTX 280 GPU and achieved performance of 36 GFLOP/s in single precision and 16 GFLOP/s in double precision. [44] developed SPMV techniques that utilizes large percentages of peak bandwidth for throughputoriented architectures like the GPU. They achieved over an order of magnitude performance improvement over a quadcore Intel Clovertown system.
To pursue a better computational efficiency, several recent works focus on using FPGA as an accelerator for SPMV. Zhuo et al. [31] proposed an FPGAbased design on VirtexII Pro for SPMV. Their design outperforms generalpurpose processors, but the performance is limited by memory bandwidth. Fowers et al. [45] proposed a novel sparse matrix encoding and an FPGAoptimized architecture for SPMV. With lower bandwidth, it achieves and higher power efficiency over CPU and GPU respectively while having lower performance due to lower memory bandwidth. Dorrance et al. [21] proposed a scalable SMVM kernel on Virtex5 FPGA. It outperforms CPU and GPU counterparts with computational efficiency and has 3850 improvement in energy efficiency.
For compressed deep networks, previously proposed SPMV accelerators can only exploit the static weight sparsity. They are unable to exploit dynamic activation sparsity (), and they are unable to exploit weight sharing (), altogether energy saving is lost.
Ix Conclusion
Fullyconnected layers of deep neural networks perform a matrixvector multiplication. For realtime networks where batching cannot be employed to improve reuse, these layers are memory limited. To improve the efficiency of these layers, one must reduce the energy needed to fetch their parameters.
This paper presents EIE, an energyefficient engine optimized to operate on compressed deep neural networks. By leveraging sparsity in both the activations and the weights, and taking advantage of weight sharing and quantization, EIE reduces the energy needed to compute a typical FC layer by 3,400 compared with GPU. This energy saving comes from four main factors: the number of parameters is pruned by 10; Weightsharing reduced the weights to only 4 bits. Then the smaller model can be fetched from SRAM and not DRAM, giving a 120 energy advantage; and since the activation vector is also sparse, only 30% of the matrix columns need to be fetched for a final 3 savings. These savings enable an EIE PE to do 1.6 GOPS in an area of 0.64mm and dissipate only 9mW. 64 PEs can process FC layers of AlexNet at 1.8810^{4} frames/sec. The architecture is scalable from one PE to over 256 PEs with nearly linear scaling of energy and performance. On 9 fullyconnected layer benchmarks, EIE outperforms CPU, GPU and mobile GPU by factors of , and , and consumes , and less energy than CPU, GPU and mobile GPU, respectively.
bstctl:etal, bstctl:nodash, bstctl:simpurl
References
 [1] A. Krizhevsky, I. Sutskever, and G. E. Hinton, “Imagenet classification with deep convolutional neural networks,” in NIPS, 2012.
 [2] C. Szegedy, W. Liu, Y. Jia, P. Sermanet, S. Reed, D. Anguelov, D. Erhan, V. Vanhoucke, and A. Rabinovich, “Going deeper with convolutions,” arXiv:1409.4842, 2014.
 [3] K. Simonyan and A. Zisserman, “Very deep convolutional networks for largescale image recognition,” arXiv:1409.1556, 2014.
 [4] T. Mikolov, M. Karafiát, L. Burget, J. Cernockỳ, and S. Khudanpur, “Recurrent neural network based language model.” in INTERSPEECH, September 2630, 2010, 2010, pp. 1045–1048.
 [5] Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner, “Gradientbased learning applied to document recognition,” Proceedings of the IEEE, vol. 86, no. 11, pp. 2278–2324, 1998.
 [6] Y. Taigman, M. Yang, M. Ranzato, and L. Wolf, “Deepface: Closing the gap to humanlevel performance in face verification,” in CVPR. IEEE, 2014, pp. 1701–1708.
 [7] A. Karpathy and L. FeiFei, “Deep visualsemantic alignments for generating image descriptions,” arXiv:1412.2306, 2014.
 [8] A. Coates, B. Huval, T. Wang, D. Wu, B. Catanzaro, and N. Andrew, “Deep learning with cots hpc systems,” in 30th ICML, 2013.
 [9] M. Horowitz. Energy table for 45nm process, Stanford VLSI wiki. [Online]. Available: https://sites.google.com/site/seecproject
 [10] T. Chen, Z. Du, N. Sun, J. Wang, C. Wu, Y. Chen, and O. Temam, “Diannao: a smallfootprint highthroughput accelerator for ubiquitous machinelearning,” in ASPLOS, 2014.
 [11] Y. Chen, T. Luo, S. Liu, S. Zhang, L. He, J. Wang, L. Li, T. Chen, Z. Xu, N. Sun, and O. Temam, “Dadiannao: A machinelearning supercomputer,” in MICRO, December 2014.
 [12] Z. Du, R. Fasthuber, T. Chen, P. Ienne, L. Li, T. Luo, X. Feng, Y. Chen, and O. Temam, “Shidiannao: shifting vision processing closer to the sensor,” in ISCA. ACM, 2015, pp. 92–104.
 [13] C. Farabet, C. Poulet, J. Y. Han, and Y. LeCun, “Cnp: An fpgabased processor for convolutional networks,” in FPL, 2009.
 [14] J. Qiu, J. Wang, S. Yao, K. Guo, B. Li, E. Zhou, J. Yu, T. Tang, N. Xu, S. Song, Y. Wang, and H. Yang, “Going deeper with embedded fpga platform for convolutional neural network,” in FPGA, 2016.
 [15] A. Shafiee and et al., “ISAAC: A convolutional neural network accelerator with insitu analog arithmetic in crossbars,” ISCA, 2016.
 [16] S. Han, J. Pool, J. Tran, and W. J. Dally, “Learning both weights and connections for efficient neural networks,” in Proceedings of Advances in Neural Information Processing Systems, 2015.
 [17] R. Girshick, “Fast RCNN,” arXiv:1504.08083, 2015.
 [18] S. Hochreiter and J. Schmidhuber, “Long shortterm memory,” Neural computation, 1997.
 [19] A. Graves and J. Schmidhuber, “Framewise phoneme classification with bidirectional lstm and other neural network architectures,” Neural Networks, 2005.
 [20] N. D. Lane and P. Georgiev, “Can deep learning revolutionize mobile sensing?” in International Workshop on Mobile Computing Systems and Applications. ACM, 2015, pp. 117–122.
 [21] Richard Dorrance and Fengbo Ren and Dejan Marković, “A Scalable Sparse Matrixvector Multiplication Kernel for Energyefficient Sparseblas on FPGAs,” in FPGA, 2014.
 [22] V. Nair and G. E. Hinton, “Rectified linear units improve restricted boltzmann machines,” in ICML, 2010.
 [23] S. Han, H. Mao, and W. J. Dally, “Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding,” International Conference on Learning Representations 2016.
 [24] R. W. Vuduc, “Automatic performance tuning of sparse matrix kernels,” Ph.D. dissertation, UC Berkeley, 2003.
 [25] N. Muralimanohar, R. Balasubramonian, and N. P. Jouppi, “Cacti 6.0: A tool to model large caches,” HP Laboratories, pp. 22–31, 2009.
 [26] NVIDIA. Technical brief: NVIDIA jetson TK1 development kit bringing GPUaccelerated computing to embedded systems.
 [27] NVIDIA. Whitepaper: GPUbased deep learning inference: A performance and power analysis.
 [28] Y. Jia, E. Shelhamer, J. Donahue, S. Karayev, J. Long, R. Girshick, S. Guadarrama, and T. Darrell, “Caffe: Convolutional architecture for fast feature embedding,” arXiv:1408.5093, 2014.
 [29] J. Deng, W. Dong, R. Socher, L.J. Li, K. Li, and L. FeiFei, “Imagenet: A largescale hierarchical image database,” in Computer Vision and Pattern Recognition. 2009.
 [30] F. N. Iandola, S. Han, M. W. Moskewicz, K. Ashraf, W. J. Dally, and K. Keutzer, “Squeezenet: Alexnetlevel accuracy with 50x fewer parameters and¡ 0.5mb model size,” arXiv:1602.07360, 2016.
 [31] Ling Zhuo and Viktor K. Prasanna, “Sparse MatrixVector Multiplication on FPGAs,” in FPGA, 2005.
 [32] V. Eijkhout, LAPACK working note 50: Distributed sparse data structures for linear algebra operations, 1992.
 [33] A. Lavin, “Fast algorithms for convolutional neural networks,” arXiv:1509.09308, 2015.
 [34] S. J. Hanson and L. Y. Pratt, “Comparing biases for minimal network construction with backpropagation,” in NIPS, 1989.
 [35] Y. LeCun, J. S. Denker, S. A. Solla, R. E. Howard, and L. D. Jackel, “Optimal brain damage.” in NIPs, vol. 89, 1989.
 [36] B. Hassibi, D. G. Stork et al., “Second order derivatives for network pruning: Optimal brain surgeon,” Advances in neural information processing systems, pp. 164–164, 1993.
 [37] E. L. Denton, W. Zaremba, J. Bruna, Y. LeCun, and R. Fergus, “Exploiting linear structure within convolutional networks for efficient evaluation,” in NIPS 2014.
 [38] X. Zhang, J. Zou, X. Ming, K. He, and J. Sun, “Efficient and accurate approximations of nonlinear convolutional networks,” arXiv:1411.4229, 2014.
 [39] B. Reagen, P. Whatmough, R. Adolf, S. Rama, H. Lee, S. K. Lee, J. M. HernÃ¡ndezLobato, G.Y. Wei, and D. Brooks, “Minerva: Enabling lowpower, highlyaccurate deep neural network accelerators,” ISCA, 2016.
 [40] S. K. Esser and et al., “Convolutional networks for fast, energyefficient neuromorphic computing,” arXiv:1603.08270, 2016.
 [41] C. Zhang, P. Li, G. Sun, Y. Guan, B. Xiao, and J. Cong, “Optimizing fpgabased accelerator design for deep convolutional neural networks,” in FPGA, 2015.
 [42] Alexander Monakov and Anton Lokhmotov and Arutyun Avetisyan, “Automatically tuning sparse matrixvector multiplication for GPU architectures,” in HiPEAC, 2010.
 [43] N. Bell and M. Garland, “Efficient sparse matrixvector multiplication on cuda,” Nvidia Technical Report NVR2008004, Tech. Rep., 2008.
 [44] Bell, Nathan and Garland, Michael, “Implementing Sparse Matrixvector Multiplication on Throughputoriented Processors,” in High Performance Computing Networking, Storage and Analysis, 2009.
 [45] J. Fowers and K. Ovtcharov and K. Strauss and E.S. Chung and G. Stitt, “A high memory bandwidth fpga accelerator for sparse matrixvector multiplication,” in FCCM, 2014.