At-Scale Evaluation of Weight Clustering to Enable Energy-Efficient Object Detection

TL;DR

This paper evaluates weight clustering at scale for YOLOv3 object detection on real driving videos, demonstrating significant reductions in bandwidth and energy consumption with minimal accuracy loss, informing accelerator design.

Contribution

It provides a comprehensive at-scale assessment of weight clustering for YOLOv3 in real-world driving scenarios, highlighting its effectiveness in energy and bandwidth savings.

Findings

Weight clustering reduces bandwidth to 30-40% of original.

Energy consumption decreases by approximately 55%.

Layer-wise clustering with 5-8 bits maintains near-original accuracy.

Abstract

Accelerators implementing Deep Neural Networks for image-based object detection operate on large volumes of data due to fetching images and neural network parameters, especially if they need to process video streams, hence with high power dissipation and bandwidth requirements to fetch all those data. While some solutions exist to mitigate power and bandwidth demands for data fetching, they are often assessed in the context of limited evaluations with a scale much smaller than that of the target application, which challenges finding the best tradeoff in practice. This paper sets up the infrastructure to assess at-scale a key power and bandwidth optimization - weight clustering - for You Only Look Once v3 (YOLOv3), a neural network-based object detection system, using videos of real driving conditions. Our assessment shows that accelerators such as systolic arrays with an Output Stationary architecture turn out to be a highly effective solution combined with weight clustering. In particular, applying weight clustering independently per neural network layer, and using between 32 (5-bit) and 256 (8-bit) weights allows achieving an accuracy close to that of the original YOLOv3 weights (32-bit weights). Such bit-count reduction of the weights allows shaving bandwidth requirements down to 30%-40% of the original requirements, and reduces energy consumption down to 45%. This is based on the fact that (i) energy due to multiply-and-accumulate operations is much smaller than DRAM data fetching, and (ii) designing accelerators appropriately may make that most of the data fetched corresponds to neural network weights, where clustering can be applied. Overall, our at-scale assessment provides key results to architect camera-based object detection accelerators by putting together a real-life application (YOLOv3), and real driving videos, in a unified setup so that trends observed are reliable.

Tables

Table 1. Table 1 : Modelled DRAM configuration.

DRAM Configuration
Type:	DDR4-3200
Size (GB)	1
Channels	8
Bus width (bits)	64
Burst length (bits)	64
Technology (nm)	45
Page size (KB)	1
Energy per read (pJ)	2937
Energy per write (pJ)	2937
Interface frequency (GHz)	3.2

Table 2. Table 2 : Modelled SRAM configuration.

SRAM Configuration
Bus width (bits)	32
Burst length (bits)	32
Technology (nm)	45

Table 3. Table 3 : DRAM Average Read and Write Energy.

Row Miss Read Energy (pJ)	2937
Row Hit Read Energy (pJ)	1735
Average Read Energy (pJ)	1753
Row Miss Write Energy (pJ)	2953
Row Hit Write Energy (pJ)	1859
Average Write Energy (pJ)	1876

Table 4. Table 4 : SRAM read energy for each cluster configuration.

Configuration	SRAM size (bytes)	Read Energy (pJ)
Cluster-8 bits	1024	0.85
Cluster-7 bits	512	0.52
Cluster-6 bits	256	0.40
Cluster-5 bits	128	0.36

Table 5. Table 5 : Bandwidth, FPS, and energy comparison.

Configuration	Bandwidth	FPS	Relative energy
	GB/s		Memory only	Overall
Baseline	200.0	25	100.0%	100.0%
Clustered 8 bits	77.1	65	38.9%	48.4%
Clustered 7 bits	73.0	68	38.9%	48.4%
Clustered 6 bits	68.9	73	34.8%	45.9%
Clustered 5 bits	63.4	79	32.0%	42.6%

Equations

$$n_{i,j}=b_{i,j}+\sum _{k=1}^{m_{i-1}}{n}_{i-1,k}\times w_{i,k,j}$$

$$\#MACs=O_w\times O_h\times W_w\times W_h\times W_c\times W_f$$

Full text

This paper sets up the infrastructure to assess at-scale a key power and bandwidth optimization – weight clustering – for You Only Look Once v3 (YOLOv3), a neural network-based object detection system, using videos of real driving conditions. Our assessment shows that accelerators such as systolic arrays with an Output Stationary architecture turn out to be a highly effective solution combined with weight clustering. In particular, applying weight clustering independently per neural network layer, and using between 32 (5-bit) and 256 (8-bit) weights allows achieving an accuracy close to that of the original YOLOv3 weights (32-bit weights). Such bit-count reduction of the weights allows shaving bandwidth requirements down to 30%-40% of the original requirements, and reduces energy consumption down to 45%. This is based on the fact that (i) energy due to multiply-and-accumulate operations is much smaller than DRAM data fetching, and (ii) designing accelerators appropriately may make that most of the data fetched corresponds to neural network weights, where clustering can be applied. Overall, our at-scale assessment provides key results to architect camera-based object detection accelerators by putting together a real-life application (YOLOv3), and real driving videos, in a unified setup so that trends observed are reliable.

1 Introduction

Computing platforms deliver increasing levels of performance over time, which has allowed deploying performance-hungry functionalities across many applications and domains. For instance, camera-based object detection is used in a plethora of applications building on deep neural networks (DNNs), whose accuracy already matches the needs of many of those applications [1, 2], with realizations such as ResNet-101 [3], ResNet-152 [3], YOLO [4] and YOLOv3 [5]. Detection accuracy and computing cost (e.g., in the form of number of arithmetic operations needed) have also been used as key parameters to compare DNNs [5]. However, other parameters such as memory bandwidth and energy consumption are also key to adopt specific DNN implementations.

Due to efficiency, DNN applications are often implemented using specialized accelerators that devote most resources (e.g. area and power) to do effective computing work such as performing multiply-and-accumulate (MAC) operations, which have been shown to be the basis of DNNs [6]. Those accelerators include systolic arrays [7], GPUs [8], as well as other application-specific designs [9]. However, in all cases, those accelerators require fetching large amounts of data that include (i) the image to be processed, and (ii) the weights of the DNN implemented [10]. Generally, this implies that large volumes of data need to be fetched from DRAM memory where data is stored.

DRAM energy consumption has been shown to be the main source of energy consumption whenever data locality is poor and DRAM accesses are frequent [11], hence making the computing unit (e.g. the accelerator) require large and sustained amounts of data being fetched from DRAM memory. In the particular case of camera-based object detection, DNNs with some acceptable degree of accuracy processing large enough images (e.g. as in the case of autonomous driving) may easily need to fetch some gigabytes of data to handle each image, being most of it due to the weights that need to be fetched for the DNN [5]. Hence, data locality cannot realistically be achieved since images to be processed change every few milliseconds, and the weights that need to be reused across images require too much space (i.e. hundreds of MBs) to store them in any local cache or register file. Therefore, reducing the amount of data to be fetched for energy reasons, but also to reduce the memory bandwidth requirements, is a key challenge for the design of systems for camera-based object detection.

Different approaches have been investigated to decrease memory energy and bandwidth requirements of DNNs, being reduced precision and weight clustering two of the most prominent ones. The former, reduced precision [12], aims at using lower precision arithmetic, and hence, lower precision data representations, to decrease the amount of data needed. For instance, using 32-bit floating point numbers instead of 64-bit ones halves the amount of data needed. On the other hand, reducing precision further discretizes the weights of the DNN, hence, impacting accuracy. Therefore, it can be used to some extent. The latter, weight clustering [12], is orthogonal to the former and aims at restricting the number of different weights to a limited number (e.g., 128 different values) while keeping their precision (e.g., each of those 128 values is a 32-bit floating point number) so that those high-precision weights need being fetched just once (e.g., 128 32-bit values), and the weights used by the DNN are encoded with fewer bits (e.g., 7 bits per weight instead of 32) to select the particular full-precision weight that must be used in each case. While reduced precision could be used instead of weight clustering matching the number of precision bits (e.g., 7-bit weights) to the bits used for clustered weights, both of them would have almost identical memory bandwidth requirements (e.g., 7 bits per weight both, plus 128 32-bit values for weight clustering), but weight clustering provides much higher precision (e.g., 32-bit weights instead of 7-bit ones) and hence, better prediction accuracy [12].

The energy savings achieved with weight clustering have only been illustrated with limited examples, but, to our knowledge, the bandwidth reduction and energy savings of weight clustering have not been evaluated in realistic (at scale) case studies.

This paper addresses this challenge by assessing the gains that can be achieved with weight clustering in terms of memory bandwidth and energy in the context of a real-size application, the YOLOv3 camera-based object detector [5], which we assess with real driving videos for its use in the context of autonomous driving. In particular, the contributions of this work are as follows:

• •

We integrate different power models for the MAC units, the DRAM memory, and the SRAMs needed by weight clustering in a consistent framework to estimate the energy consumption of the DRAM and accelerator devices with and without weight clustering.

• •

We integrate YOLOv3 with the power models to estimate the energy consumption to process each frame from a video.

• •

We assess the tradeoff between overall energy, memory bandwidth and prediction accuracy of weight clustering using both, reference labelled data sets and videos from real driving conditions. Our evaluation considers both, global and per-layer clustered weights, and different numbers of weight clusters, from 32 (5 bits) up to 256 (8 bits).

Our results show that weight clustering can be effectively used to preserve detection accuracy while decreasing significantly memory bandwidth requirements and overall energy in the context of autonomous driving. In particular, per-layer weight clusters show to be particularly effective to preserve accuracy unaffected with 7-bit and 8-bit clusters decreasing DRAM energy consumption by around 60% w.r.t. the original 32-bit data used by YOLOv3. Our results show that, with negligible accuracy loss, 5-bit clusters allow reaching DRAM energy reductions of around 68%. Bandwidth also drops from 200 GB/s for 25 frames-per-second (FPS) down to 60-80 GB/s depending on the bits used for clustering.

The rest of the paper is organized as follows. Section 2 provides some background on DNNs, appropriate accelerators and weight clustering. Section 3 presents the case study. Section 4 evaluates the case study. Related work is provided in Section 5. Section 6 summarizes this work.

2 Background

This section provides some background on DNNs in general, and Convolutional Neural Networks (CNNs) in particular. It also provides some details on dataflow accelerators for DNNs, and introduces clustering and its application to DNN weights.

2.1 DNNs

DNNs may include tens or even more than one hundred hidden layers, which is not generally the case for other types of neural networks. Figure 1 illustrates the general structure of a DNN. DNNs consist of an input layer with $n$ inputs, an output layer with $m$ outputs and $k$ hidden layers in-between, where $n$, $m$ and $k$ are at least $1$. Each node is called a neuron and its value is computed with the values of the neurons in the previous layer that are connected to it, the weights associated to these connections and a bias. The weights and biases are learned in the training phase. In the model shown in Figure 1, all neurons are fully connected across layers, however, this is not always the case.

Formally, a neuron is computed as presented in Equation 1, where $n_{i,j}$ denotes a neuron in position $j$ of layer $i$, $w_{i,k,j}$ is the weight of the connection between $n_{i-1,k}$ and $n_{i,j}$, $m_{i-1}$ denotes the number of neurons in layer $i-1$, and $b_{i,j}$ is the bias of $n_{i,j}$.

[TABLE]

CNNs are one of the most popular types of DNNs. CNNs architecture encodes image-specific features allowing it to be primarily used for finding patterns in images to recognize objects. CNNs are comprised of an input layer that holds the pixel values of the image, convolutional layers that perform convolutions of the inputs with the weights and biases, pooling layers that downsample the spatial dimensionality of the input, fully-connected layers that produce class scores, and an output layer that holds the final classification of the objects [10].

Figure 2 shows the traditional 2-D convolution used for image processing. The weights consist of an $W_{h}\times W_{w}$ matrix, the inputs of an $I_{h}\times I_{w}$ matrix, and the outputs of an $O_{h}\times O_{w}$ matrix. The output height $O_{h}$ can be calculated as $O_{h}=\frac{W_{h}-I_{h}+2P}{S}+1$, where $W_{h}$ is the number of rows of the weights, $I_{h}$ is the number of rows of the inputs, $P$ is the padding value (i.e. the number of rows and columns added to the frame of the image if needed, to cover the entire image with the sliding window), and $S$ is the stride value (i.e. the number of positions to move the sliding window). The output width is calculated using the number of columns instead of the number of rows, $O_{w}=\frac{W_{w}-I_{w}+2P}{S}+1$.

The process of a 2-D convolution is performed with a sliding window in which the weight window moves through the entire input, performing an element-wise multiplication and accumulation. In the example shown, we can see that the weights are multiplied by a $W_{h}\times W_{w}$ subset of the input and accumulated to obtain a single output element. The window then moves through the entire image to compute all the $O_{h}\times O_{w}$ outputs.

2.2 YOLOv3 Object Detection System

YOLOv3 [4, 5] is a camera-based detection software framework capable of processing images efficiently in real-time. YOLOv3 implements one of the DNNs delivering higher accuracy, and hence, it is very popular and has already been adopted as part of several industrial applications, including Apollo [13], which is an industrial autonomous driving framework. YOLOv3 [5] is capable of detecting around 80 different classes of objects, including multiple animals, common objects and food, but also multiple types of vehicles, pedestrians and road signs, with the latter three groups being of particular relevance for autonomous driving.

For each image processed, YOLOv3 detects the objects in it and attaches each one a confidence level describing the confidence on the detection and classification of such object (i.e., a value between 0% and 100%). However, a confidence threshold is used to drop those objects whose confidence is below the threshold (e.g., 50%), hence keeping only those for which the detection has been performed with sufficiently high confidence.

We use Darknet framework [14], developed by YOLO authors, implementing YOLOv3 model for image and video processing. For the sake of reliability, Darknet averages confidence levels across a specific number of images in the case of video processing (e.g., across 3 images). This allows mitigating false positives and false negatives that occur in just one frame, since their sporadic and erroneous confidence is averaged with that of the two previous frames. For that purpose, the average for each value of the YOLO layer output of the current image and the YOLO layer output of the previous two images is calculated.

Finally, YOLOv3 provides two different models; Tiny YOLOv3, which is a lighter and simplified version of YOLOv3 that can run over 200 frames per second, but at the cost of lower accuracy, and the baseline YOLOv3, which is a more sophisticated model with longer execution time but also more accurate. In this work we have used the baseline YOLOv3, which provides the highest accuracy and is, generally, more relevant for industry.

2.3 Accelerators for DNNs

In this work, our reference accelerator is assumed to have an architecture such that its energy per MAC is low (i.e., most power dissipation occurs in MAC units), and whose utilization can be kept high (e.g., close to 100%) in the case of DNNs. These two characteristics are the basis of a high-performance and power-efficient accelerator for DNNs.

Systolic arrays [15] adhere to those characteristics. Their typicall architecture is depicted in Figure 3 for illustration purposes. As shown, such an accelerator includes an array of processing elements (PEs) capable of performing MACs (e.g., a MAC per cycle if properly pipelined). In particular, those PEs multiply inputs and weights, and accumulate the result with the output. Each PE is normally implemented with its own local (and small) register file (RF) or scratchpad memory, which is used to retain data to be reused so that data locality can be effectively exploited minimizing costly data transactions. Generally, those RFs allow retaining one of the three operands of the MAC, whereas the other two need being fetched for each operation from a slower and higher power memory (DRAM in our case), or forwarded by other PEs.

Depending on what data is kept in the PE-local RFs, different dataflows can be defined. For instance, a weight stationary dataflow keeps the weights to be operated in those RFs with the aim of not having to fetch them, hence maximizing their reuse and reducing the energy consumption devoted to fetch weight. An output stationary dataflow, instead, stores in the RF the results of the MACs to be accumulated with the results of the following MACs to be executed. Such architecture intends to minimize the energy consumption needed to read and write output results. Other possible dataflows – although less popular – include input stationary dataflows to minimize the energy devoted to fetch inputs, row stationary dataflows that aim at reducing the energy devoted to fetch all data types simultaneously (i.e., inputs, weights and outputs), and no local reuse dataflows that do not reuse any data, but allow removing RFs from the PEs.

As shown later in this work, we consider an Output Stationary dataflow, as it is a popular dataflow that can benefit significantly from using weight clustering.

2.4 Weight Clustering

Weights of a DNN typically are the largest set of data to fetch, and so it is in the case of YOLOv3, which requires roughly 8 GB of weights to be fetched from memory to process each single image. This poses, obviously, high pressure on the memory bandwidth to allow real-time operation. For instance, if a value of 25 FPS is wanted – typical for video processing – around 200 GB/s of memory bandwidth are required. This is an overwhelming cost for autonomous driving systems, both in terms of the hardware procurement costs to allow such a high bandwidth, and in terms of power to read so much data per second. Note that autonomous driving systems employ multiple cameras and lots of other sensors which increase the bandwidth and computation requirements manifold resulting in significant pressure on the memory subsystem.

This work assesses the effectiveness of a quantization technique called Weight Clustering or Sharing to mitigate the cost of fetching weights for DNNs. In particular, we assess its impact in both, accuracy and energy consumption. Weight clustering has been shown to be an effective solution to decrease the size of the data to be operated with very limited impact on accuracy. Weight clustering builds on limiting the number of different weights to be used, which are represented with fewer bits while preserving the original precision of the weights. This is achieved by making multiple weights being identical by using the mean value of a cluster (i.e. a group of weights), with those weights being stored in a centroid table (also known as codebook table). K-means [16, 17] is the most popular clustering algorithm. This algorithm works by finding the similarity between the data and grouping the data in $K$ groups called clusters.

Using this technique, the FP32 values of the weights used by YOLOv3 that are stored in a DRAM are replaced by smaller integer indices that are used to access the centroid table. Note that this table may be orders of magnitude smaller than the weights and can fit in a small on-chip SRAM within the systolic array. This adds the extra cost of performing an indirection, but since the indirection fetches data from a tiny on-chip SRAM with a significantly shorter access time than the DRAM, the expected overhead is negligible and clustering is expected to significantly reduce the power and memory bandwidth used to fetch the weights from memory. In terms of delay, weight translation through the centroid table can be organized to occur ahead of time so that full 32-bit weights are available in the PEs whenever needed. For instance, if we set $K=256$ clusters for K-means, we will require only 256 different FP32 weights for the DNN, and we will be able to encode the weights of the DNN with only 8 bits to identify the particular FP32 weight to use for each one of them. The centroid table will have to store 256 unique FP32 values, which is only 1KB of data. Note that the size of the centroid table is independent of the number of weights of the DNN.

For the sake of illustration, we provide a small example where we have 1,000 32-bit (e.g., FP32) weights, see left side of Figure 4. Those require 32,000 bits of storage. However, using K-means, in this example, we identify 4 32-bit values that can be used for clustering the 1,000 potentially different 32-bit values. We refer to those 4 clustered weights as weight A, weight B, weight C, and weight D in the figure. As shown in the central part of the figure, we replace each one of the original 32-bit weights by the representative weight of the cluster where the corresponding weight has been mapped to with K-means. This intermediate step is only shown for illustrative purposes, but not applied in practice. Finally, we replace each of the 1,000 32-bit weights by a 2-bit index indicating to what of the 4 32-bit values such weight has been mapped. Therefore, as shown in the rightmost part of the figure, we need 1,000 2-bit values to store the clustered weights and the translation table with the 4 32-bit weights, 2,128 bits in total, which corresponds to a 15x storage reduction in this example.

Note that using reduced precision, as mentioned before, leads to similar memory bandwidth requirements (2,000 bits in the example). However, using lower precision constrains the accuracy of the DNN. In the example, we could only use 2-bit values for the weights. This reduces the cost of the arithmetic, but restricting precision impacts accuracy if the number of bits used becomes too low. Instead, weight clustering keeps similar bandwidth requirements to those of comparable precision reduction (e.g., 2,128 bits vs 2,000 bits in the example), but allows using weights with much higher precision (e.g., 32-bit weights), which are operated with the appropriate arithmetic units (e.g., FP32 arithmetic in the example) and hence, allows the DNN reaching much higher accuracy than just using lower precision [18, 19, 20, 21, 22, 23, 24].

3 Case Study Modelling

This section presents the design and modelling choices for our case study. Those choices relate to the underlying design of the systolic array, the actual application of weight clustering, the power model, and the input data used for evaluation.

3.1 Systolic Array

As discussed in Section 2.3, systolic arrays can be organized in different ways depending on what data is fetched, and what data remains stationary – if any. Given that weight clustering allows a drastic reduction of the bandwidth and energy requirements related to fetching weights, it is expected that the most appropriate dataflow is the one where any other type of data (inputs and outputs) requires low bandwidth and energy. Otherwise, Amdahl’s law would severely limit the achievable gains. Therefore, a systolic array with an output stationary dataflow is the most appropriate baseline organization to consider. Such an organization allows keeping intermediate results local in the PEs until they are final, hence not needing to fetch them. Weights, instead, must be fetched every time they are required, and they account for a much larger size than input data operated, potential gains with weight clustering are huge if we use an output stationary dataflow since the number of bits per weight that must be fetched from memory is drastically reduced.

Moreover, despite not being explicitly evaluated in our study, output stationary systolic arrays minimize write operations to memory since intermediate results are not sent out. If the memory space where those results are stored is coherent, write operations may trigger coherence messages into the cores, potentially harming performance. Hence, minimizing those write operations may also bring benefits in terms of reduction of coherence messages triggered.

3.2 Weight Clustering Application

In our case study, we consider two alternative ways to realize weight clustering:

• •

All layers (global). In this case, clustering is applied using as input all weights of all layers at once. This approach minimizes the number of weights needed, but may impact accuracy since all layers are enforced to use the same set of weights.

• •

Per layer (local). Clustering is applied separately to the weights of each layer individually. Accuracy is gained since each layer may use the best set of weights for the corresponding layer. On the other hand, weights need to be loaded every time a new layer starts. Note, however, that the cost of fetching few floats (e.g. between 32 and 256 floats) per layer is negligible compared to the typical tens of MBs of data needed per layer.

To implement both alternatives, we have used the K-means algorithm, as indicated before, and modified the relevant functions of YOLOv3 to read and process the weights accordingly. Listing 1 shows the changes made to the convolution operation, showing the added indirection needed to fetch the weights. Line 10 corresponds to the original weight read operation, and line 11 to the operation using clustering. Note that the example corresponds to the simple case with 8-bit clustered weights. We have used also lower numbers of bits (5, 6 and 7), whose code is similar to the case of 8 bits, but require some bit manipulation given that they are not byte aligned.

K-means has already been considered in the past realize clustering of activations and/or weights [18, 19, 23, 24, 20, 22, 25, 21, 26, 27, 28, 29, 30]. However, to our knowledge, our work is the first one assessing the benefits, in terms of energy and bandwidht, of post-training weight clustering for an at-scale case study such as YOLOv3.

3.3 Power Model

For our assessment, we have modelled the main power contributors of an accelerator running the DNN, namely DRAM accesses and MAC operations [12]. Since centroids tables are direct overheads of weight clustering, we have also included their energy consumption modelling them as SRAM tables. Instead, other components of the accelerator, such as its peripheral logic, have not been included as their contribution to the total energy of the accelerator is relatively small and, in any case, it will not experience significant variations regardless of whether weight clustering is used or not.

3.3.1 Modelled DRAM and SRAM specifications

In our at-scale assessment of YOLOv3, we must take into account two type of memories: DRAM memory where data is stored and fetched from, and the centroids tables (SRAM memories) used when weight clustering is implemented. Both types of memories have been modelled using the CACTI tool [31], which models energy consumption, as well as area and delay, for a wide range of memories. Hence, it allows collecting DRAM and SRAM energy estimates building on comparable models. Tables 1 and  2 describe the specific parameters used to model DRAM and SRAM memories respectively in our case study. Regarding the technology node considered, it has been chosen to keep consistency with the energy values available for MAC operations, taken from [19], as described later. This allows modelling properly the contribution to total energy of each component, and hence, obtaining results where the relative cost of DRAM and MAC energy consumption is kept consistent and trends are meaningful, despite absolute values do not correspond to the latest technology nodes in the market.

For DRAM accesses, the energy reported in Table 1 corresponds to 8-byte random accesses. However, an output stationary dataflow exploits spatial reuse in the memory row buffers [32]. Hence, assuming 1 KB row buffers, we can expect 1 row miss every 128 accesses, while the remaining 127 accesses are row hits, whose energy consumption is significantly lower. Since CACTI does not provide data for row hits, we have used DRAMsim3 [33] to estimate the relation between row hits energy consumption and row misses one. For that purpose, we have collected energy measurements for a sequence of one of the default DRAM configurations (DDR4_1Gb_x16_1866) and we have used two traces to estimate the energy ratio of row hits and misses. To do so we have executed read and write access traces with spatial locality (1 miss followed by 127 hits) and without spatial locality (all misses), and extrapolated the energy consumption of hits w.r.t. misses. Results of each access type are shown in Table 3.

Regarding the SRAM memory for centroids, its size and energy vary depending on the clustering configuration as reported in Table 4. Note that, in this case, the reported SRAM read and write energy is for fetching 32 bits of data, since weights for YOLOv3 are 32-bit floating point numbers. The read ports number of the SRAM memory has been set large enough to allow translating as many weights as fetched per cycle in each case. In any case, SRAM energy cost is negligible regardless of its number of ports and size since it is several orders of magnitude smaller than that of DRAM accesses. Regarding SRAM static energy, it has also been included but it is completely negligible even if we assume a physical SRAM per layer as potentially needed in the per-layer clustering. In fact, very few tables would be needed if we load centroids right before they are needed, but as said, SRAM static energy is simply irrelevant (below 0.1% of the total energy in all cases).

3.3.2 Number of Memory Accesses

Memory access counts have been computing building on the feature maps of the weights, outputs, and inputs, their padding and stride, and the dataflow of the accelerator (Output Stationary in our case), as well as considering spatial data reuse. We consider the memory accesses of all layers in the neural network used by YOLOv3 for object detection, namely, the convolutional, route, upsample, shortcut, and YOLO layers.

We note that YOLOv3 has 3 types of weight filters: 3x3 with Stride 1, 3x3 with Stride 2, and 1x1 with Stride 1. Next, we specify the formulas for calculating the number of memory accesses based on the three types of weights, where appropriate. The meanings of the abbreviations used in the formulas are, W: Weights, I: Inputs, O: Outputs and the meaning of the subscripts, w: width, h: height, c: channels, and f: filters.

For the number of memory accesses, it is assumed that each access fetches/writes a single FP element (32 bits). Knowing that the modelled DRAM has a bus width of 64 bits and that the read/write energy reported is for 64-bit accesses, we divide the number of accesses by 2 for DRAM accesses.

• •

Convolutional Layer: Performs the convolutions between weights and inputs.

• –

Weight Reads (3x3, Stride 1, Stride 2) = $W_{w}\times W_{h}\times W_{c}\times W_{f}\times(I_{h}-2)$

• –

Weight Reads (1x1, Stride 1) = $W_{w}\times W_{h}\times W_{c}\times W_{f}\times I_{h}$

• –

Input Reads (3x3, Stride 1) = $I_{w}\times W_{h}\times W_{c}\times(I_{h}-2)$

• –

Input Reads (3x3, Stride 2) = $(I_{w}+1)\times W_{h}\times W_{c}\times(I_{h}-2)$

• –

Input Reads (1x1, Stride 1) = $I_{w}\times W_{h}\times W_{c}\times I_{h}$

• –

Output Writes = $O_{h}\times O_{w}\times W_{f}$

• •

Shortcut Layer: Add the feature maps of two layers.

• –

Reads: $I_{h}\times I_{w}\times I_{c}+I_{h^{\prime}}\times I_{w^{\prime}}\times I_{c^{\prime}}$

• –

Writes: $I_{h}\times I_{w}\times I_{c}+I_{h^{\prime}}\times I_{w^{\prime}}\times I_{c^{\prime}}$

• •

Route Layer: Outputs a specific layer or concatenates two layers.

• –

Reads One Layer: $I_{h}\times I_{w}\times I_{c}$

• –

Reads Concatenation: $I_{h}\times I_{w}\times I_{c}+I_{h^{\prime}}\times I_{w^{\prime}}\times I_{c^{\prime}}$

• –

Writes One Layer: $I_{h}\times I_{w}\times I_{c}$

• –

Writes Concatenation: $I_{h}\times I_{w}\times I_{c}+I_{h^{\prime}}\times I_{w^{\prime}}\times I_{c^{\prime}}$

• •

Upscale Layer: Upscales the output of a layer (2x upscaling in our case).

• –

Reads: $I_{h}\times I_{w}\times I_{c}$

• –

Writes: $4\times I_{h}\times I_{w}\times I_{c}$

• •

YOLO Layer: Performs the object detections.

• –

Reads: $I_{h}\times I_{w}\times I_{c}$

• –

Writes: $I_{h}\times I_{w}\times I_{c}$

3.3.3 Number of FP operations and their energy estimation

The number of FP operations has been computed using different procedures for convolutional layers and the other layers. For convolutional ones, we use the following formula to compute the number of MACs:

[TABLE]

To calculate the number of FP operations from other layers or sources (such as the activations), we have used software counters. The FP operations used during object detection are the following: addition (FPADD), multiplication (FPMUL), subtraction (FPSUB), division (FPDIV), exponential (FPEXP), and square root (FPSQRT).

Energy consumption of FP operations has been obtained from [19] in the case of FPADD and FPMUL, for a 45nm technology node, which, as discussed before, is in synch with the one sued for our memory models (DRAM and SRAM) to perform fair energy comparisons. However, we lack explicit energy estimates for FPDIV, FPSUB, FPSQRT and FPEXP. Nevertheless, those operations represent a negligible part of the FP operations performed by YOLOv3 since the MACs of the convolutional layer already account for 99.54% of the overall FP operations in YOLOv3. Hence, we have modelled those other operations, which represent a fraction of the remaining 0.46% FP operations, considering that their energy consumption matches that of an FPMUL operation.

3.4 Datasets

For our case study, we have used two different types of datasets: a labelled one, and a set of real driving videos.

A labelled dataset is composed by a set of images labelled by humans. This means that, for each image, the bounding boxes of the objects have been drawn and classified as accurately as possible by a human. These accurate bounding boxes are called ground truths and are used to compare against the predicted bounding boxes of an object detector, to determine its accuracy by using different metrics. Due to its large number of images, and due to defining object categories comparable to those of YOLOv3, we have used the COCO dataset [34]. In particular, this dataset contains ten thousand high quality images of complex everyday scenes containing common objects in their natural context. Moreover, the training set of this dataset is the one used to train YOLOv3. The drawback of this dataset is that we are mostly interested in images of road scenes taken from vehicle cameras, but this dataset contains more general contexts. Therefore, we have dropped all those images that do not include any vehicle, therefore keeping 880 images. In any case, note that the fact that those images include vehicles does not imply that they belong to driving scenarios. Hence, the accuracy of the object detection process for this set of images is only relevant in relative terms to compare the accuracy of different setups, but not to obtain conclusions from the absolute values.

We have also considered a set of unlabelled automobile videos to complement the analysis of labelled data. To perform this analysis, we have used thirty seconds extracts, taken at 30 FPS, from six videos of real driving conditions, which provide more relevant input data for your case study [35, 36, 37, 38, 39, 40]. The main disadvantage of using these videos is that we lack a ground truth for comparison purposes since videos are unlabelled. Hence, the only possible comparison is to build the default YOLOv3 without weight clustering as if it was the ground truth. This may lead to some pessimism in terms of accuracy for weight clustering since it is frequent that objects in the boundary between being identified or discarded (e.g. those whose confidence of detection is around 50%) are relatively often misclassified, being either false positives or false negatives. Hence, a relevant number of misclassified objects in the baseline YOLOv3 may be properly classified with weight clustering – partly due to the stochastic nature of the object detection process – but accounted as misclassifications due to the lack of a ground truth.

In the case of videos, we fully build on the redundancy delivered by YOLOv3 so that, as explained before, object detections are given averaging the confidence level obtained across multiple frames – 3 in particular – rather than the confidence values obtained frame by frame. This approach mitigates the risk of sporadic misclassifications. For instance, an object detected with confidence levels 80%, 90% and 40% across three frames would be regarded as a detection with 70% confidence, thus above the threshold (e.g. 50%) despite in the last image it was below the threshold.

3.5 Practical Integration in an Accelerator

Weight clustering can be integrated in multiple manners in an accelerator. The simplest one consists of a translation layer for weights fetched from memory so that the internal design of the accelerator remains unchanged. This is illustrated in Figure 5 for a systolic array accelerator, where arrows width indicates bit-width. As shown, the accelerator stores and operates full weights as in a non-weight clustering design. Cluster IDs are fetched from memory and immediately translated into full weights to keep the accelerator design unchanged. This has the advantage of being non-intrusive with the accelerator design. However, this prevents exploiting the fact that cluster IDs require fewer bits than full weights, so that IDs could be propagated further delaying the translation.

Figure 6 shows a completely opposed design approach where ID translation occurs as late as possible, right before data are operated in the PEs. This allows column and row management logic (i.e. feeders) use small IDs (e.g. 6-bit) rather than full weights (e.g. 32-bit), as well as narrower connections to transmit weights to PEs. On the other hand, translations may occur in further locations simultaneously, so likely weight translation tables need being replicated across multiple locations. Overall, there is a trade-off between decreasing the width of the weights propagated by using IDs instead of full weights, and the cost of replicating translation logic in multiple locations. Note that intermediate solutions where, for instance, translation occurs per column or per row are also possible, therefore providing other trade-offs to choose the most effective one, which is fully accelerator dependent and may change across different accelerator architectures or topologies.

4 Evaluation

This section evaluates the different tradeoffs between accuracy, energy consumption and memory bandwidth for both, the COCO dataset and the real driving videos.

4.1 Energy Breakdown

To illustrate the energy contribution of DRAM accesses to fetch DNN weights in the baseline YOLOv3 configuration, we start estimating the energy consumption devoted to both components, namely DRAM accesses and FP operations, with the model described in previous section applied to YOLOv3. In particular, we estimate the energy needed to process one image. As shown in Figure 8, 2086 mJ are required to process an image, which would correspond to 52 Watts if one image was processed every 40ms (i.e., 25 FPS). As shown, 84.4% of such energy is devoted to DRAM accesses, which are, therefore, the main energy contributor.

Figure 8 shows the distribution of memory accesses of the baseline YOLOv3, dividing the memory accesses into weights (only reads), inputs (only reads), and outputs (reads and writes). As shown, 81.9% of the DRAM accesses correspond to weights, whereas inputs and outputs account for 12.0% and 6.1% only respectively. Hence, weights are the main energy contributor of DRAM accesses.

If we put both results together, we come to the conclusion that DRAM accesses to fetch weights almost account for 70% of the total energy for the considered output stationary systolic array. Hence, weight clustering has significant potential to decrease both, energy consumption and bandwidth requirements.

4.2 Accuracy Evaluation

To compare the accuracy of the different configurations considered, we use the Mean Average Precision (mAP) [41]. The mAP is used as a standard metric to evaluate and compare the accuracy of object detectors leveraging true positives, false negatives and false positives into a single value (the mAP). Such value allows assessing and comparing the prediction accuracy of object detectors. The mAP builds upon the Intersection over Union (IoU) metric [42], which determines whether two bounding boxes overlap enough to regard them as the same object detection. We refer the interested reader to the original works describing those metrics for further details. To measure the mAP in our experiments, we use the public implementation provided in [43].

The results when applying weight clustering for the labelled dataset are shown in Figure 9, where we provide the mAP for person and vehicle categories together. Clustering accuracy is given for those configurations providing relevant mAP values, namely between 5 and 8 bits, thus discarding weight clustering with 4 bits or fewer. More than 8 bits have not been considered since 8 bits already achieves mAP values very close to those of the non-clustered YOLOv3.

Results include per-layer clustering (left) as well as global clustering for all layers (right). As shown in the figure, mAP remains high for 7-bit and 8-bit clusters independently of whether clustering is applied for all layers at once or per layer. However, if we further reduce the number of clusters to 64 (6 bits) or 32 (5 bits), then only per-layer clustering achieves acceptable mAP. Instead, with those few clusters, if we apply clustering simultaneously to all layers, accuracy degrades significantly.

The reduction of the data size for the different configurations is shown in Figure 10. For instance, 8-bit weight clustering produces a 4x data reduction given that each weight is stored as an 8-bit index rather than a 32-bit FP number in DRAM memory. Note that, if only the labelled dataset is considered, 5-bit clusters per layer offer very good accuracy and a size reduction factor for weights above 6, meaning that original weights (32 bits) require more than 6x memory space than clustered ones (5 bits).

Figure 11 shows the mAP for vehicle and person objects together for the videos. First, note that there is some drop in the mAP w.r.t. the baseline. Visual inspection reveals that, as indicated before, this is not real accuracy loss but different object classifications for objects in the boundary. In general, this effect is mostly captured in the mAP drop when using 8-bit clusters. Therefore, additional accuracy loss can be confidently attributed to the impact of clustering on accuracy.

As shown, 8-bit clusters (global and per layer) and 7-bit clusters (global only) achieve high accuracy. Regarding 7, 6, and 5-bit clusters per layer, mAP drops moderately. However, 6 and 5-bit clusters applied globally lead to dramatic accuracy loss.

Overall, the best setups correspond to 8-bit clusters, or to 7, 6 or 5-bit per layer clusters depending on the degree of accuracy that can be sacrificed for the sake of reducing energy consumption and memory bandwidth requirements.

4.3 Bandwidth Evaluation

Memory bandwidth requirements for the different clustering configurations as well as for the baseline YOLOv3 are provided in Table 5. Note that in all cases we assume that object detection must be performed at a rate of 40ms per frame (25 FPS). Under these assumptions, the baseline YOLOv3 requires 200 GB/s (199.97 to be more precise) of DRAM memory bandwidth. The particular DRAM modelled has a theoretical maximum bandwidth of 204.8 GB/s (8 channels * 3.2 GHz * 8 bytes per transfer). Hence, it could sustain the bandwidth required very tightly. Clustering, instead, allows reducing bandwidth requirements down to 63-77 GB/s (i.e., a reduction of the bandwidth required between 61% and 68%), therefore enabling the use of less aggressive (and cheaper) DRAM memory systems. Hence, we could achieve 25 FPS with a memory system delivering much lower bandwidth (e.g., a memory offering 63.4 GB/s would allow reaching 25 FPS if 5-bit clusters are used). In other words, if we keep the same DRAM memory reaching 204 GB/s, weight clustering would allow reaching 65-79 FPS.

4.4 Energy Evaluation

First, we have evaluated the energy consumption of the centroids table using SRAM memories across the different configurations, hence varying the SRAM size, the number of ports, as well as the number of SRAMs (tables) needed in each case. Energy consumption of the centroids tables is below 0.1% of the total energy in all cases. Therefore, while it is included in the estimates, we do not further discuss its contribution in the rest of this section.

Table 5 (column corresponding to relative memory energy) provides the results for DRAM and SRAM memories consolidated. In particular, it reports their relative energy consumption with respect to the baseline configuration. As shown, weight clustering achieves large memory energy reductions in the range 61-68%. In our evaluation, we assume that all data are word aligned (32-bit alignment) so that no weight value spans across two different 32-bit words. Therefore, 8-bit and 7-bit clustering allow storing 4 weights per word, whereas 6-bit clustering and 5-bit clustering can encode 5 and 6 weights per 32-bit word respectively. Hence, 8-bit and 7-bit clustering achieve analogous energy savings, as shown in the table. Since the centroids tables produce negligible energy consumption, the difference between applying clustering per-layer or globally is negligible (largely below 0.1%), so results with one decimal digit match across both configurations in all cases, and therefore, we do not report them twice.

Results also accounting for the energy consumed by FP operations are shown in the last column. Overall, clustering achieves total energy reductions in the range 52-57%, and hence, energy consumption is between 43% and 48% that of the original YOLOv3 without weight clustering. Note also that the reduction between a given number of bits for clustering between All Layers and Per Layer approaches is virtually the same as discussed before.

4.5 Tradeoff Analysis

Figures 12 and  13 put together accuracy and energy savings in a single plot for the video dataset and labelled dataset, respectively. In the figures, the AL abbreviation indicates clustering of All Layers, and the PL abbreviation indicates clustering Per Layer. Note that, since bandwidth relates highly linearly with energy consumption, we use only energy consumption in the plots.

Looking at both plots, we can reach the following two conclusions: (1) if accuracy has more importance than energy, then 8-bit clusters, either for all layers or per layer, provide high energy savings with limited impact in accuracy. (2) However, if energy consumption is the most relevant feature to optimize, then 5-bit clusters per layer are the best choice since they deliver an additional 6% energy reduction w.r.t. 8-bit clusters, and its accuracy is larger than that of any other configuration providing comparable energy savings.

Note that 7-bit AL provides virtually the same accuracy as 8-bit clustering for the labelled dataset. However, its accuracy is lower for the video dataset. Therefore, 8-bit clustering is a better option overall. Analyzing the results, we reach the conclusion that some configurations could be safely discarded: e.g., 7-bit PL and 7-bit AL could be discarded, since 8-bit PL and 8-bit AL provide the same energy reduction but provide higher accuracy. 6-bit PL and 6-bit AL could also be discarded, since 5-bit PL provides both, higher energy reductions and higher accuracy. Lastly, 5-bit AL can be discarded since its accuracy is not acceptable, and 5-bit PL provides the same energy reduction with an acceptable accuracy.

5 Related Work

Related works in the area of clustering for neural networks are abundant. The work from Han et al. [18] analyses the impact of clustering and network pruning during training and also Huffman coding after training for LeNet-300, LeNet-5, AlexNet, and VGG-16, but does not analyze the energy impact of weight clustering alone. Han et al. [19] also propose the first accelerator using clustering, pruning and Huffman coding building on top of the previous work. The work analyzes the three techniques combined and 16-bit fixed-point data to be able to reduce the model to fit it into an on-chip SRAM, consuming orders of magnitude less energy than a DRAM. This is not possible in our case since the YOLOv3 model cannot be reduced as drastically applying only clustering without sacrificing accuracy significantly.

Choi et al. [20] propose a similar workflow to Han et al. [18], implementing pruning, clustering, and Huffman coding on LeNet, ResNet, and AlexNet. The work proposes the use of the Hessian-weighted k-means to perform weight quantization, showing that the Hessian-weighted k-means is a viable alternative to the traditional k-means algorithm and allows applying weight clustering to the entire model, rather than per layer as used by Han et al. [18], with negligible accuracy loss. Wang et al. [21] propose an accelerator for CPU+FPGA-based heterogeneous platforms for YOLOv2 by exploiting pruning, weight-clustering, and quantization. However, this work uses the PASCAL VOC dataset to assess the accuracy of the different configurations, while our work uses a more recent version of YOLO, and provides a more complex case study of real driving videos. Moreover, our work focuses on the weight-clustering technique, providing an in-depth analysis of its hardware implications, and the accuracy and energy impact for different clustering configurations. Ye et al. [22] is a more recent work that studies pruning and clustering in LeNet-5, AlexNet, and VGG-16 using the MNIST and Imagenet datasets. The work proposes the use of ADMM-based pruning and clustering to exploit the maximum degree of data redundancy. Their approach quantizes a portion of the weights in each training iteration, retraining the non-quantized weights, outperforming prior works. Tung et al. [25] propose to perform pruning and quantization in parallel during the training process, and analyze the accuracy impact in AlexNet, GoogleNet, and Resnet. Authors claim that their methodology allows recovery from premature pruning. However, their work uses uniform quantization, which consists of dividing the numerical range of weights into uniform parts, as opposed to k-means, which is a non-uniform quantization method.

Other works [23, 24] also explore K-means clustering in terms of accuracy, but do not report energy analyses. It is also worth noting that most works analyze clustering in much less complex neural networks than YOLO, and focus on the image classification domain. Because of this significant complexity difference, works such as [23] achieve as low as 1-bit weights, but this is not feasible with YOLOv3 when applying post-training clustering. Works such as [26, 27] also propose binary weights during training. Other works consider other forms of quantization such as integer quantization [28] or uniform quantization [29, 30].

In our case study, we assess the impact of post-training weight clustering in terms of accuracy and energy for a large case study such as YOLOv3. The main contribution of our work is the in-depth accuracy and energy analysis of weight clustering for a complex camera-based object detection system, covering the gap of previous works. To the best of our knowledge, our work is the first one to provide such a complex case study, thus helping designers make the right choice for the design of their accelerators and providing hints on how to evaluate accuracy, energy and bandwidth at scale.

6 Conclusions and Future Work

Weight clustering is a promising solution to decrease the memory bandwidth requirements and energy consumption of DNNs. However, it has been evaluated in limited examples so far, hence providing insufficient information of its real benefits and tradeoffs. This paper presents an at-scale case study considering different flavors of weight clustering, the main characteristics of an appropriate accelerator with the right dataflow, a relevant application such as YOLOv3 for camera-based object detection, and both, reference datasets as well as real driving condition videos. Our results provide relevant information in terms of memory bandwidth and energy consumption, showing that energy gains range between 61% and 68% for memory, and between 52% and 57% for the whole framework with different degrees of accuracy. Our results also allow concluding that, if applied aggressively (e.g., 5-bit clusters), weight clustering must be better applied in a per-layer basis to mitigate accuracy degradation.

As part of our ongoing work, we are contributing to the design of a systolic array accelerator that adopts the findings in our work with the aim of offering it as open source (with permissive licenses). Such accelerator will be further integrated in RISC-V open source SoCs.

Acknowledgements

The DRAC project under grant 001-P-001723 is co-financed by the European Union Regional Development Fund within the framework of the ERDF Operational Program of Catalonia 2014-2020 with a grant of 50% of total eligible cost. This work has also been partially supported by the Spanish Ministry of Science and Innovation under grant PID2019-107255GB-C21/AEI/10.13039/501100011033.