Efficient Network Construction through Structural Plasticity

TL;DR

This paper introduces CGaP, a training scheme inspired by biological structural plasticity, which starts with a small network, continuously grows important units, and prunes secondary ones, leading to more efficient neural networks.

Contribution

It proposes a novel training approach that dynamically adjusts network structure during training, improving efficiency and adaptability over traditional fixed-structure methods.

Findings

Reduces FLOPs by 63.3% on ResNet-110

Decreases model size and energy consumption significantly

Achieves 40.2% reduction in inference latency

Abstract

Deep Neural Networks (DNNs) on hardware is facing excessive computation cost due to the massive number of parameters. A typical training pipeline to mitigate over-parameterization is to pre-define a DNN structure first with redundant learning units (filters and neurons) under the goal of high accuracy, then to prune redundant learning units after training with the purpose of efficient inference. We argue that it is sub-optimal to introduce redundancy into training for the purpose of reducing redundancy later in inference. Moreover, the fixed network structure further results in poor adaption to dynamic tasks, such as lifelong learning. In contrast, structural plasticity plays an indispensable role in mammalian brains to achieve compact and accurate learning. Throughout the lifetime, active connections are continuously created while those no longer important are degenerated. Inspired by such observation, we propose a training scheme, namely Continuous Growth and Pruning (CGaP), where we start the training from a small network seed, then literally execute continuous growth by adding important learning units and finally prune secondary ones for efficient inference. The inference model generated from CGaP is sparse in the structure, largely decreasing the inference power and latency when deployed on hardware platforms. With popular DNN structures on representative datasets, the efficacy of CGaP is benchmarked by both algorithm simulation and architectural modeling on Field-programmable Gate Arrays (FPGA). For example, CGaP decreases the FLOPs, model size, DRAM access energy and inference latency by 63.3%, 64.0%, 11.8% and 40.2%, respectively, for ResNet-110 on CIFAR-10.

Tables

Table 1. TABLE I: Evaluation of the performance on MNIST.

Method	Accuracy	FLOPs	Pruned	Param.	Pruned
LeNet5-Baseline	99.29	4.59M	–	431K	–
Pruning [17]	99.26	0.85M	81.5%	112K	74.0%
Pruning [15]	99.23	0.73M	84.0%	36K	92.0%
CGaP	99.36	0.44M	90.4%	8K	98.1%

Table 2. TABLE II: Evaluation of the performance on CIFAR-100. ‘NA’ means ‘not available’ in the original paper.

Method	Accuracy	FLOPs	Pruned	Param.	Pruned
VGG19-Baseline	72.63	797M	–	20.4M	–
Pruning [28]	71.85	NA	–	10.1M	50.5%
Pruning [18]	72.85	501M	37.1%	5.0M	75.5%
CGaP	73.00	373M	53.2%	4.3M	78.9%

Table 3. TABLE III: Evaluation of the performance on SVHN.

Method	Accuracy	FLOPs	Pruned	Param.	Pruned
VGG19-Baseline	96.02	797M	–	20.4M	–
Pruning [18]	96.13	398M	50.1%	3.1M	84.8%
CGaP	96.25	206M	74.2%	2.9M	85.8%

Table 4. TABLE IV: Evaluation of the performance on CIFAR-10.

Method	Accuracy	FLOPs	Pruned	Param.	Pruned
VGG16-Baseline	93.25	630M	–	15.3M	–
Pruning [16]	93.40	410M	34.9%	5.4M	64.7%
CGaP	93.59	280M	56.2%	4.5M	70.6%
ResNet-56-Baseline	93.03	268M	–	0.85M	–
Pruning [28]	92.56	182M	32.1%	0.73M	14.1%
Pruning [43]	90.20	134M	50.0%	NA	-
CGaP	93.20	181M	32.5%	0.53M	37.6%
ResNet-110-Baseline	93.34	523M	–	1.72M	–
Pruning [16]	93.11	310M	40.7%	1.16M	32.6%
Pruning [29]	93.52	300M	40.8%	NA	–
CGaP	93.43	192M	63.3%	0.62M	64.0%

Table 5. TABLE V: The impact of various structures and and sizes of the initial seed of VGG-19.

Initial seeds		‘2’	‘4’	‘6’	‘8’	‘10’	‘12’
#filters	conv1_$n$	2	4	6	8	10	12
	conv2_$n$	4	8	12	16	20	24
	conv3_$n$	8	16	24	32	40	48
	conv4_$n$	16	32	48	64	80	96
	conv5_$n$	16	32	48	64	80	96
#param	Initial (M)	0.01	0.06	0.13	0.23	0.36	0.53
Testing accuracy*		-0.69%	-0.2%	-0.16%	+0.37%	+0.04%	0.29%
*Relative accuracy of the final VGG-19 model on CIFAR-100 as compared to the baseline.

Equations

$$\underset{W_l^o}{\mathrm{argmin}}$$

$$\underset{W_l^o}{\mathrm{argmin}}|\mathcal{L}(\mathcal{Y};\mathcal{X},\mathcal{W})-\mathcal{L}(\mathcal{Y};\mathcal{X},W_l^o=0)|.$$

$$|\mathcal{L}(\mathcal{Y};\mathcal{X},\mathcal{W})-\mathcal{L}(\mathcal{Y};\mathcal{X},W_l^o=0)|at{W}_l^o=0.$$

$$|\Delta \mathcal{L}(W_l^o)|$$

$$=\sum _{i=0}^{I_l}\sum _{m=0}^K\sum _{n=0}^K|\frac{\partial \mathcal{L}(\mathcal{Y};\mathcal{X},\mathcal{W})}{\partial W_l^{o,i,m,n}}{W}_l^{o,i,m,n}|.$$

$$|\Delta \mathcal{L}(N_l^i)|$$

$${\mathbf{W}}_{l,newborn}^j=\sigma {\mathbf{W}}_{l,picked}^j+X\sim U([-\mu ,\mu ]),$$

$${\mathbf{W}}_{l,picked}^j=\sigma {\mathbf{W}}_{l,picked}^j+X\sim U([-\mu ,\mu ]),$$

$${\mathbf{W}}_{l+1,mapped}^j=\sigma {\mathbf{W}}_{l+1,projected}^j+X\sim U([-\mu ,\mu ]),$$

$${\mathbf{W}}_{l+1,projected}^j=\sigma {\mathbf{W}}_{l+1,projected}^j+X\sim U([-\mu ,\mu ]).$$

$${\mathbf{W}}_{l-1,mapped}^j=\sigma {\mathbf{W}}_{l-1,projected}^j+X\sim U([-\mu ,\mu ]),$$

$${\mathbf{W}}_{l-1,projected}^j=\sigma {\mathbf{W}}_{l-1,projected}^j+X\sim U([-\mu ,\mu ]).$$

$$P{S}_{W_l^{o,i,m,n}}=$$

$$P{S}_{W_l^{o,i}}=$$

Full text

I Introduction

Deep Neural Networks have various applications including image classification [1], object detection [2], speech recognition [3] and natural language processing [4]. However, the accuracy of DNNs heavily relies on massive amounts of parameters and deep structures, making it hard to deploy DNNs on resource-limited embedded systems. When training or inferring the DNN models on hardware, the model must be stored in the external memory such as dynamic random-access memory (DRAM) and fetched multiple times. These operations are expensive in computation, memory access, and energy consumption. For example, Fig. 1 shows the energy consumption of one inference pass in several modern DNN structures, simulated by the FPGA performance model [5] under the setting of 300 MHz operating frequency and 19.2 GB/s DRAM bandwidth. The input image size is $32\times 32$. A typical DNN model is too large to fit in on-chip memory. For instance, VGG-19 [6] has 20.4M parameters. Running such a model requires frequent external memory access, exacerbating the power consumption of a typical embedded system.

Previous researches have designed customized hardware for DNN acceleration [7, 8]. Most of them are limited to relatively small neural networks, such as LeNet-5 [9]. For larger networks such as AlexNet [1] and VGG-16 [6], additional efforts are usually required to improve the hardware efficiency [10, 11]. For example, [10] saves the energy through data gating and zero skipping. Some other works focus on data reuse of convolutional layers and demonstrate the results on specific hardware [7, 12, 13, 14]. However, their improvements are limited on those networks where fully-connected layer is widely used, such as RNNs and LSTMs.

To support more general models, network pruning is a popular approach by removing secondary weights and neurons. Network pruning executes a three-step procedure, which

1. trains a pre-designed network from scratch,
2. removes less important connections or filters/neurons according to a saliency score (a metrics to measure the importance of weights and learning units) [15, 16, 17, 18, 19], or by adding a regularization term into the loss function [20, 21], and
3. fine-tunes to recover the accuracy.

However, the above pruning techniques suffer from two limitations: (1) training a large and fixed network from scratch could be sub-optimal as it introduces redundancy; (2) in the process of training, pruning only discards less important weights at the end of training but does not strengthen important weights and nodes. These limitations of network pruning confine the learning performance as well as the model pruning efficiency (i.e., how many parameters can be removed and how structured the sparsity is).

In contrast to the static DNN model, the biological nervous system exhibits active growth and pruning through the lifetime. [22, 23, 24] have observed that the rapid growth of neurons and synapses takes place in an infant’s brain and is vital to the maturity of an adult’s brain. In brains, some neurons and synapses are used more frequently and are consequently strengthened. Those neurons and synapses that are not used consistently are weakened and removed. The structural plasticity of brain is central to the study of developmental biology.

Inspired by this observation from biology, we propose a training scheme named Continuous Growth and Pruning (CGaP), which leverages structural plasticity to tackle the aforementioned limitations of pruning techniques. Instead of training an over-parameterized network from scratch, CGaP starts the training from a small network seed (Fig. 2(a)), whose size is as low as 0.1%-3% of the full-size reference model. In each iteration of the growth, CGaP locally sorts neurons and filters (also known as output channels in some literature) according to our saliency score (Section III-B). Based on the saliency score, important learning units are selected and the corresponding new units are added (see Fig. 2(b)). The selection and addition of important units help reinforce the learning and increase model capacity. Then a filter-wise and neuron-wise pruning will be executed on the post-growth model (Fig. 2(c)) based on pruning metrics. Finally, CGaP generates a significantly sparse and structured inference model (Fig. 2(d)) with accuracy improved. In the generated inference model, large amounts of filters and neurons have been removed, achieving structured pruning. Compared to non-structured pruning [15], CGaP benefits hardware implementation as it reduces the computation volume and memory access without any additional hardware architecture change.

Algorithmic experiments and hardware simulations validate that CGaP significantly decreases the number of external and on-chip memory accesses, accelerating the inference by bypassing the removed filters and neurons. On the algorithm side, we demonstrate the performance in accuracy and model pruning on several networks and datasets. For instance, CGaP reduces $78.9\%$ parameters of VGG-19 with $+0.37\%$ accuracy improvement on CIFAR-100 [25], $85.8\%$ parameters with $+0.23\%$ accuracy improvement on SVHN [26]. For ResNet-110 [27], CGaP reduces $64.0\%$ parameters with $+0.09\%$ accuracy improvement on CIFAR-10 [25]. These results exceed the state-of-the-art pruning methods [15, 16, 17, 18, 28, 29]. Furthermore, we validate the efficiency of the inference model generated from CGaP using FPGA simulator [5]. For one inference pass of VGG-19 on CIFAR-100, previous non-structured pruning approach [15] requires energy consumption of $2.7\times 10^{9}$ pJ in accessing DRAM and 5.6 ms inference latency, while CGaP requires only $2.2\times 10^{9}$ pJ and 4.4 ms latency.

The contribution of this paper is as follows:

• •

A brain-inspired training flow (CGaP) with a dynamic structure is proposed. CGaP grows the network from a small seed and effectively reduces over-parameterization without sacrificing accuracy.

• •

The advantage of structured sparsity of the inference model generated from CGaP is validated using a high-level FPGA performance model including on-chip buffer access energy, external memory access energy and inference latency.

• •

The discussion and understanding of the reason that the growth improves the learning efficiency are provided.

The rest of the paper is organized as follows. Section II introduces the background of model pruning. Section III demonstrates the saliency score used to select the learning units. Section IV describes the proposed Continuous Growth and Pruning scheme. Section V presents the experimental results from algorithmic simulations. Section VI demonstrates the simulation results from FPGA performance modeling. Section VII discusses the understanding of network plasticity as well as ablation study. Section VIII concludes this work and discusses the insight into future work.

II Previous Work

There have been broad interests in reducing the redundancy of DNNs in order to deploy them on a resource-limited hardware platform. The structural surgery is a widely used approach and can be categorized into destructive direction and constructive direction. We will discuss these two directions, as well as orthogonal approaches to our methods in this section.

II-A Destructive Methods

The destructive methods zero out specific connections or remove filters or neurons in convolutional or fully-connected layers, generating a sparse model. Weight magnitude pruning [15] pruned weights by setting the selected weights to zeros. The selection is based on L1-norm, i.e., the absolute value of the weight. Weight magnitude pruning generates a sparse weight matrix, but not in a structured way. In this case, specific hardware design [30] is needed to take advantage of the optimized inference model, otherwise the non-structured sparsity does not benefit hardware acceleration due to the overhead in model management. The kernel-wise pruning [16] pruned kernels layer by layer based on the saliency metrics of each filter and achieved structured sparsity in the inference model. Compared to [16], CGaP prunes filters, leading to a more structured inference model. Besides the saliency-based pruning, the penalty-based approach has been explored by [21, 31] and structured sparsity was achieved. Our method is different from all the above pruning schemes from two perspectives: (1) We start training from a small seed other than an over-parameterized network; (2) Besides removing secondary filters/neurons, we also reinforce important ones to further improve learning accuracy and model compactness.

II-B Constructive Methods

The constructive approaches include techniques that add new connections or filters to enlarge the model capacity. [32, 33] increased network size by adding random neurons with fresh initialization (i.e., weights are randomly initialized, without pre-trained information). They evaluated their approach on basic XOR problems. Different from their approach, CGaP selectively adds neurons and filters that are initialized with the information learned from the previous training. Meanwhile, CGaP is validated on modern DNNs and datasets under more realistic scenarios. [34] grew the smallest Neural Tree Networks (NTN) to minimize the number of classification errors on Boolean function learning tasks, and used pruning to enhance the generalization of NTN.  [35] improved the accuracy of radial basis function (RBF) networks on function approximation tasks by adding and removing hidden neurons. To enhance the accuracy of spike-based classifiers,  [36] progressively added dendrites to the network, and then optimized the topology of the dendritic tree. Different from them, CGaP aims at improving the efficiency of the inference model of modern Deep Neural Networks on image classification tasks.  [37] constructed the DNN by activating connections and choosing a set of convolutional filters among a bunch of randomly generated filters according to their influence on the training performance. However, this approach highly depends on trial and error to find the optimal set of filters that could reduce loss the most. This approach is sensitive to power and timing budgets, limiting its extension on large datasets. Unlike their work, CGaP directly grows the network from a seed, minimizing the effort on trail and error.

II-C Orthogonal Methods

The orthogonal methods, such as low-precision quantization and low-rank decomposition, compress the DNN models by quantizing the parameters to fewer bits [38, 39], or by finding a low-rank approximation [40, 41]. Note that our CGaP approach can be combined with these orthogonal methods to further improve inference efficiency.

III Saliency Score

In this section, we describe the detailed methodology of CGaP, starting from the saliency score, which is used to sample the importance of a learning unit. Section III-A defines the terminology we use in this paper. Section III-B provides the mathematical proof of the saliency score we adopt.

III-A Terminology

A DNN can be treated as a feedforward multi-layer architecture that maps the input images to certain output vectors. Each layer is a certain function, such as convolution, ReLU, pooling and inner product, whose input is $\mathcal{X}$, output is $\mathcal{Y}$ and parameter is $\mathcal{W}$ in case of convolutional and fully-connected layers. Hereby the convolutional layer (conv-layer) is formulated as: $\mathcal{Y}_{l}=\mathcal{X}_{l}\ast\mathcal{W}_{l}$, wherein $\mathcal{X}_{l}\in\mathbb{R}^{I_{l}\times Wi_{l}\times Hi_{l}}$, $\mathcal{Y}_{l}\in\mathbb{R}^{O_{l}\times Wo_{l}\times Ho_{l}}\Leftrightarrow\mathcal{X}_{l+1}\in\mathbb{R}^{I_{l+1}\times Wi_{l+1}\times Hi_{l+1}}$, $\mathcal{W}_{l}\in\mathbb{R}^{O_{l}\times I_{l}\times K\times K}$, where subscript l denotes the index of the layer. And the fully-connected layer is represented by: $\mathcal{Y}_{l}=\mathcal{X}_{l}\cdot\mathcal{W}_{l}$, where the input $\mathcal{X}_{l}\in\mathbb{R}^{I_{l}}$, the output $\mathcal{Y}_{l}\in\mathbb{R}^{O_{l}}\Leftrightarrow\mathcal{X}_{l+1}\in\mathbb{R}^{I_{l+1}}$, and the parameter matrix is $\mathcal{W}_{l}\in\mathbb{R}^{O_{l}\times I_{l}}$.

Convolutional layer (conv-layer) $l$

the 4 dimensions of its weight matrix are: the number of output channels $O_{l}$, the number of input channels $I_{l}$, and the kernel width and height $K$, respectively. We denote the $o$-th 3D filter, which generates the $o$-th output channel in the feature map, as $W^{o}_{l}\in\mathbb{R}^{I_{l}\times K\times K}$. The $i$-th 2D kernel in the $o$-th filter is denoted as $W_{l}^{o,i}\in\mathbb{R}^{K\times K}$. On the other hand, a 4D weight tensor $\mathbf{W}_{l}^{i}\in\mathbb{R}^{O_{l}\times 1\times K\times K}$ , which operates on the $i$-th input feature map, is a package of $O_{l}$ kernels across all output channels. For example, in Fig. 3, $W_{l,picked}^{j}$ is a 3D filter consisting of $I_{l}$ kernels, and $\mathbf{W}_{l+1,projected}^{j}$ as well as $\mathbf{W}_{l+1,mapped}^{j}$ are both 4D tensors with dimension of $O_{l}\times 1\times K\times K$, which include all the output channels but have only one input channel located at j. The $W_{l}^{o,i,m,n}\in\mathbb{R}^{1\times 1}$ refers to one weight at the $m$-th row and the $n$-th column in the $o$-th filter of the $i$-th input channel.

Fully-connected layer (fc-layer) $l$

input $\mathcal{X}_{l}$ propagate from one hidden activation $i$ to the next layer. We refer the whole set of $W^{i}_{l,fan-out}$ as a neuron $N^{i}_{l}$. This neuron receives information from previous layer $l-1$ through its fan-in weights $W_{l,fan-in}^{i}\in\mathbb{R}^{1\times I_{l-1}}$ (as shown in Fig. 4) and propagates to the next layer through fan-out weights $W^{i}_{l,fan-out}\in\mathbb{R}^{O_{l}\times 1}$. Also note that the output dimension of layer $l-1$ equals to the input dimension of layer $l$, i.e., $O_{l-1}=I_{l}$. The weight pixel in layer $l$ at the cross-point of row $o$ and column $i$ is denoted as $W^{o,i}_{l,fan-out}\in\mathbb{R}^{1\times 1}$. Moreover, the ‘depth’ of a DNN model indicates the number of layers, and the ‘width’ of a DNN model refers to the number of filters or neurons of each layer.

Learning units

Growing or pruning a filter $W^{o}_{l}$ indicates adding or removing $W^{o}_{l}\in\mathbb{R}^{I_{l}\times K\times K}$ and its corresponding output feature map. Growing or pruning a neuron $N^{i}_{l}$ means adding or removing both $W^{i}_{l,fan-out}\in\mathbb{R}^{O_{l}\times 1}$ and $W_{l,fan-in}^{i}\in\mathbb{R}^{1\times I_{l-1}}$.

III-B Saliency Score

We adopt a saliency score to measure the effect of a single filter/neuron on the loss function, i.e., the importance of each learning unit. The saliency score is developed from Taylor Expansion of the loss function. Previously,  [42] applied it on pruning. In this paper, we adopt this saliency score and apply it on the growth and pruning scheme. In this section, we provide a mathematical formulation of the saliency score.

The saliency score represents the difference between the loss with and without each unit. In other words, if the removal of a filter/neuron leads to relatively small accuracy degradation, this unit is recognized as an unimportant unit, and vice versa. Thus, the objective function to get the filter with the highest saliency score is formulated as:

[TABLE]

Using the first-order of the Taylor Expansion:

[TABLE]

we get:

[TABLE]

Similarly, the saliency score of a neuron is derived as:

[TABLE]

IV CGaP Methodology

With the saliency score as the foundation, we develop the entire CGaP flow atop. This section explains the overall flow and the detailed implementation of each step in CGaP.

The CGaP scheme is described in Algorithm 1. Starting from a small network seed, the growth takes place periodically at a frequency of $f_{growth}$ (see Algorithm 1 line 4, where ‘%’ denotes the operation to obtain the remainder of division). During each growth, important learning units are chosen and grown at growth ratio $\beta$ layer by layer from the bottom (input) to top (output), based on the local ranking of the saliency score. The growth phase stops when reaching a capacity threshold $\tau_{capa.}$, followed by several epochs of training on the peak model $M_{peak}$. When the training accuracy reaches a threshold $\tau_{accu.}$, the pruning phase starts. Pruning is performed layer by layer, from the bottom layer to the top layer, at the frequency of $f_{pruning}$. The details in the growth phase and the pruning phase is demonstrated as follows.

IV-A Growth phase

Algorithm 2 presents the methodology in the growth phase. Each iteration of growth in a layer consists of two steps: growth in layer $l$ and mapping in the adjacent layer. There are two conditions need to be discussed separately: convolutional layers (Fig. 3) and fully-connected layers (Fig. 4). Due to the difference between these two kinds of operation as discussed previously, after the growth of layer $l$, the mapping in conv-layer takes place at the adjacent layer $l+1$. In fc-layers, the mapping is in layer $l-1$.

Growth in conv-layer $l$

According to the local ranking of the saliency score (Eq. III-B), we sort all the 3D filters in this layer. With a growth ratio $\beta$, $\beta O_{l,t}$ filters are selected in the $l$-th layer at the $t$-th growth. On the side of each selected filter $\mathbf{W}_{l,picked}^{j}\in\mathbb{R}^{I_{l}\times K\times K}$, as shown in Fig. 3, we create a new filter that has the same size, named $\mathbf{W}_{l,newborn}^{j}\in\mathbb{R}^{I_{l}\times K\times K}$.

In the ideal case, the new filter $\mathbf{W}_{l,newborn}^{j}$ and existing filter $\mathbf{W}_{l,picked}^{j}$ are expected to collaborate with each other and optimize the learning. The existing filter $\mathbf{W}_{l,picked}^{j}$ has already learned on the current task. To keep the same learning pace between the existing filter and the new filter, we initialize $\mathbf{W}_{l,newborn}^{j}$ as follows:

[TABLE]

where $\sigma$ $\in(0,1]$ is a scaling factor and $X$ is a constant following uniform distribution in $[-\mu,\mu]$, where $\mu$ $\in(0,1]$. Instead of random initialization, the above initialization helps reconcile the learning status of the newborn filters with the old filters. Meanwhile, the scaling factor prevents output from an exponential explosion caused by the feedforward propagation $\mathcal{Y}_{l}=\mathcal{X}_{l}\ast\mathcal{W}_{l}$. The noise $X$ prevents the learning from sticking at a local minimum that leads to sub-optimal solutions. No matter which distribution the noise $X$ follows, $X$ in a reasonable range is able to provide similar performance. However, other distributions usually introduce more hyper-parameters and thus, require more efforts in parameter tuning. For example, Gaussian noise introduces more hyper-parameter, e.g., the standard deviation, than uniform noise. For simplicity, we use uniformly distributed noise.

Mapping in conv-layer $l+1$

After the number of filters in layer $l$ grows from $O_{l,t}$ to $(1+\beta)O_{l,t}$, the number of output feature maps also increases from $O_{l,t}$ to $(1+\beta)O_{l,t}$. Therefore, the input-wise dimension of layer $l+1$ should increase correspondingly in order to be consistent in data propagation. To match the dimension, we first locate the 4D tensor $\mathbf{W}_{l+1,projected}^{j}$ in layer $l+1$, which processes the feature maps generated by $W_{l,picked}^{j}$. Then we add a new 4D tensor $\mathbf{W}_{l+1,mapped}^{j}$ adjacent to $\mathbf{W}_{l+1,projected}^{j}$. The $\mathbf{W}_{l+1,mapped}^{j}$ and $\mathbf{W}_{l+1,projected}^{j}$ are initialized as follows:

[TABLE]

To summarize, as illustrated in Fig. 3, the filter $W_{l,picked}^{j}$ (green) is selected according to the saliency score and a new tensor $W_{l,newborn}^{j}$ (orange) is added. Then the input-wise tensor $\mathbf{W}_{l+1,projected}^{j}$ (in blue dashed rectangular) in layer $l+1$ is projected, and $\mathbf{W}_{l+1,mapped}^{j}$ (in black dashed rectangular) is generated.

After layer $l$ grows and layer $l+1$ is mapped, layer $l+1$ grows and layer $l+2$ is mapped, so on and so forth till the last convolutional layer. It is worth mentioning that for the ‘projection shortcuts’ [27] with $1\times 1$ convolutions in ResNet [27], the dimension mapping is between the two layers that the shortcut connects, not necessarily to be the adjacent layers.

Growth and mapping in fc-layers

As illustrated in Fig. 4, the neuron growth in fc-layers $l$ occurs at fan-out weights, and its initialization follows Eq. 5 and 6.

The mapping in fc-layers take place in the fan-in weights as follows:

[TABLE]

After growing the last conv-layer, We flatten the output feature map of this conv-layer, treat it as the input from layer $l-1$ and map in the same manner.

IV-B Pruning phase

Pruning in each layer consists of two steps: weight pruning and unit pruning. First, we sort weight pixels locally in each conv-layer according to Eq.11:

[TABLE]

and in each fc-layer according to Eq.12:

[TABLE]

In each layer, 100$\gamma_{W}$% weight pixels with the lowest $PS_{W}$ are set as zero, where $\gamma_{W}\in(0,1)$ is the weight pruning rate. Then the entire filter/neuron whose sparsity is larger than the filter/neuron pruning rate $\gamma_{F}$ or $\gamma_{N}\in(0,1)$ is set to zero. In this way, a large amount of entire filters/neurons are pruned, leading to a compact inference model.

V Algorithmic Experiments

To evaluate the proposed approach, we present experimental results in this section. We perform experiments on several modern DNN structures (LeNet [9], VGG-Net [6], ResNet [27]) and representative datasets (MNIST [9], CIFAR-10, CIFAR-100 [25], SVHN [26]).

V-A Training Setup

Network structures

The LeNet-5 architecture consists of two sets of convolutional, ReLU [44] and max pooling layers, followed by two fully-connected layers and finally a softmax classifier. The VGG-16 and VGG-19 structures we use have the same convolutional structure as [6] but are redesigned with only two fully-connected to be fairly compared with the pruning-only method [16]. Therefore, the VGG-16 (VGG-19) has 13 (16) convolutional layers, each is followed by a batch normalization layer [45] and a ReLU activation. The structures of ResNet-56 and ResNet-110 follow [16]. Each convolutional layer is followed by a batch normalization layer and ReLU activation. During the training, the depth of the networks remains constant since CGaP does not touch the depth of the network, but the width of each layer changes.

Note that in the following text, we denote the full-size models trained from scratch without sparsity regularization as ‘baseline’ models. The three-step pruning schemes that remove weights or filters but do not execute network growth are denoted as ‘pruning-only’ models.

Datasets

MNIST is a handwritten digit dataset in grey-scale (i.e., one color channel) with 10 classes from digit 0 to digit 9. It consists of 60,000 training images and 10,000 testing images. The CIFAR-10 dataset consists of 60,000 $32\times 32$ color images in 10 classes, with 5000 training images and 1000 testing images per class. The CIFAR-100 dataset has 100 classes, including 500 training images and 100 testing images per class. The Street View House Number (SVHN) is a real-world color image dataset that is resized to a fixed resolution of $32\times 32$ pixels. It contains 73,257 training images and 26,032 testing images.

Hyper-parameters

We set the learning rate to be 0.1 and divide by 10 for every 30% of the training epochs. We train our model using Stochastic Gradient Descent (SGD) with a batch size of 128 examples, a momentum of 0.9, and a weight decay of 0.0005. The loss function is the cross-entropy loss with softmax function. We train 60, 200, 220 and 100 epochs on MNIST, CIFAR-10, CIFAR-100 and SVHN datasets, respectively. In the growth phase, we have hyper-parameters set as follows: the growth stopping condition $\tau_{capa.}=O_{1,baseline}$, i.e., the growth stops at the $t$-th growth if the number of filters in the $(t+1)$-th growth is larger than the baseline model. The growth ratio $\beta$ is set as 0.6. The growth frequency $f_{growth}$ is set as 1/3. The scaling factor $\sigma$ in Eq. 5 to Eq. 10 is set to 0.5 and $\mu$ is 0.1. The pruning frequency $f_{pruning}$ is set to be 1. The setting of the weight pruning rate $\gamma_{W}$ follows [15], [16] and [18] for LeNet-5, VGG-Net and ResNet, respectively. $\gamma_{F}$ and $\gamma_{N}$ is set to be same as $\gamma_{W}$.

Framework and platform

The experiments are performed with PyTorch [46] framework on one NVIDIA GeForce GTX 1080 Ti platform. It is worth mentioning that experiments performed with different frameworks may have variation in accuracy and performance. Thus, to have a fair comparison among CGaP, baseline and pruning-only methods, all the results in Table  I, II,  III and IV are obtained from experiments with PyTorch framework.

V-B Performance Evaluation

With training setup as aforementioned, we perform experiments on several datasets with modern DNN architectures. In Table I, Table II, Table III and Table IV, we summarize the performance attained by CGaP on MNIST, CIFAR-100, SVHN, and CIFAR-10 datasets, respectively. To be specific, the second column ‘Accuracy’ denotes the inference accuracy in percentage achieved by the baseline model, the up-to-date pruning-only approaches and CGaP approach, respectively.

The column ‘FLOPs’ represent the calculated number of FLOPs of a single inference pass. The calculation of FLOPs follows the method described in [42]. Fewer FLOPs means lower computation cost in one inference pass. The neighboring column, ‘Pruned’, represents the reduction of FLOPs in the compressed model as compared to the baseline model. The column ‘Param.’ stands for the number of parameters of the inference model. Fewer parameters promise a smaller model size. The last column, ‘Pruned’, denotes the percentage pruned in parameters compared to the baseline. Larger pruned percentage implies fewer computation operations and more compact model. The best result of each column is highlighted in bold.

The results shown in Table I to IV prove that CGaP outperforms the previous pruning-only approaches in accuracy and model size. For instance, as displayed in Table IV, on ResNet-56, our CGaP approach achieves 93.20% accuracy with 32.5% reduction in FLOPs and 37.6% reduction in parameters, while the up-to-date pruning-only method [28] that deals with static structure only reaches 92.56% accuracy with 32.1% reduction in FLOPs and 14.1% reduction in parameters. On ResNet-110, though [29] achieves 0.09% higher accuracy than CGaP, CGaP overwhelms it by trimming 22.5% more FLOPs.

V-C Visualization of the dynamic structures

Fig. 5 presents the dynamic model size during CGaP training. During the growth phase, the model size continuously increases and reaches a peak capacity. When the pruning phase starts, the model size drops.

Furthermore, the sparsity achieved by CGaP is structured. In other words, large amounts of filters and neurons are entirely pruned. For instance, the baseline LeNet-5 without sparsity regularization has 20, 50 filters in conv-layer 1 and conv-layer 2, 500 and 10 neurons in fc-layer 1 and fc-layer 2, denoted as [20-50-500-10] (number of filters/neurons in [conv1-conv2-fc1-fc2]). The model achieved by CGaP contains only 8, 17 filters and 23, 10 neurons, denoted as [8-17-23-10]. Compared to baseline results, CGaP significantly decreases 60%, 66%, 95.4% units for each layer (the output layer should remain the same as the number of classes all the time). In this case, the pruned filters and neurons are skipped in the inference pass and thus accelerating the computation pipeline on hardware.

Another example is provided in Fig. 6, which visualizes the VGG-19 structures from CGaP as well as the baseline structure on two different tasks. In the baseline model, the width (number of filters/neurons) of each layer is abundant, from 64 filters (the bottom conv-layers) to 512 filters (the top conv-layers). The baseline VGG-19 structure is designed to have a large enough size in order to guarantee the learning capacity. However, it turns out to be redundant, as proved by the structure that CGaP generated: $37.7\%$ to $82.6\%$ filters are pruned out in each layer. Meanwhile, in the baseline model, the top conv-layers are designed to have more filters than the bottom layers, but CGaP shows that it is not always necessary for top layers to have a relatively large size.

V-D Validating the saliency-based growth

Fig. 7 validates the efficacy of our saliency-based growth policy. Selective growth, which emphasizes the important units according to the saliency score, has lower cross-entropy loss than randomly growing some units. The spiking in Fig. 7 is caused by the first iteration of pruning and this loss is recovered by the following iterative fine-tuning. In selective growth, this loss is $1.4\times$ lower than that in random growth. This phenomenon supports our argument that selective growth assists the pruning phase. The detailed understanding of growth will be further discussed in Section VII.

To summarize the results from the algorithm simulations, the proposed CGaP approach:

• •

Largely compresses the model size by $37.6\%$ (ResNet-56) to $98.1\%$ (LeNet-5) for representative DNN structures.

• •

Decreases the inference cost, to be specific, number of FLOPs, by $32.5\%$ (ResNet-56) to $90.4\%$ (LeNet-5) on various datasets.

• •

Does not sacrifice accuracy and even improves accuracy.

• •

Outperforms the state-of-the-art pruning-only methods that deal with fixed structures.

VI Experiments on FPGA simulator

The results above demonstrate that CGaP generates an accurate and small inference model. In this section, we further evaluate the on-chip inference cost of the generated models and compare CGaP with previous non-structured pruning [15]. As CGaP achieves structured sparsity, CGaP outperforms the previous work on non-structured pruning in hardware acceleration and power efficiency. We validate this by performing the estimation of buffer access energy, DRAM access energy and latency using the performance model for FPGA [5].

VI-A Overview of the FPGA simulator

[5] is a high-level performance model designed to estimate the number of external and on-chip memory access, as well as the latency. The resource costs are formulated by the acceleration strategy as well as the design variables that control the loop tiling and unrolling. The performance model has been validated across several modern DNN algorithms in comparison to on-board testings on two FPGAs, with the differences within $3\%$ [5].

In the following experiments, the setup follows: the pixels and weights are both 16-bit fixed point, the data width of DRAM controller is $512$ bits, the accelerator operating frequency is $300$ MHz, and the DRAM bandwidth is $19.2$ GB/second. The parameters related to loop tiling and unrolling follow the setting in [5].

VI-B Results from FPGA performance model

The on-chip and external memory access energy across VGG-16, VGG-19, ResNet-56 and ResNet-110 is displayed in Fig. 8(a) and Fig. 8(b), respectively. The inference latency is shown in Fig. 8(c). Though the models generated from weight magnitude pruning and CGaP have the same sparsity, CGaP outperforms non-structured magnitude weight pruning in hardware efficiency and acceleration. For example, with the same setup of the pruning ratio during training, magnitude weight pruning decreases $1.0\%$ on-chip access energy, $1.0\%$ DRAM access energy and $0.8\%$ latency for VGG-19 on CIFAR-100, while the CGaP achieves $21.6\%$, $15\%$, and $21.1\%$ reduction. The non-structured weight pruning [15] is able to improve the power and latency efficiency in comparison to baseline. However, the improvement is limited. In contrast, CGaP achieves significant acceleration and energy reduction. The reason is that the non-structured sparsity, i.e., scattered weight distribution, leads to irregular memory access that weakens the acceleration on hardware in a real scenario.

VII Discussion

In Section V and VI, the performance of CGaP has been comprehensively evaluated on algorithm platforms and hardware platforms. In this section, we provide a more in-depth understanding of the growth to explain why selective growth is able to improve the performance from the traditional pipelines. Furthermore, we provide a thorough ablation study to validate the robustness of the proposed CGaP method.

Understanding the growth

Fig. 9 illustrates a visualization of the weights in the bottom conv-layer (conv1_1) in VGG-19, at the moment of initialization, after the first growth, after the last growth and when training ends. Inside each figure, the upper bar is the CGaP model, whose size varies at different training moments. The lower bar is from the baseline model, whose size is static during training. At the initialization moment (Fig. 9(a)), CGaP model only has 8 filters in this layer while the baseline model has 64 filters. Then the number of filters grows to 13 after one iteration growth (Fig. 9(b)), meaning the most important 5 filters are selected and added. It is clear that the pattern in Fig. 9(b) is more active than that in (a), indicating the filters have already fetched effective features from the input images. More important, along with the growing, the pattern in CGaP model becomes more structured than that in the baseline model, as shown in Fig. 9(c). Benefiting from this well-structured pattern, our CGaP model has higher learning accuracy than the baseline model. From Fig. 9(c) to Fig. 9(d), relatively unimportant filters are removed, and important ones are kept. We observe that most of the filters that are favored by the growth, such as filters at index 36, 48, 72, 96 in Fig. 9(c), are still labeled as important filters in Fig. 9(d) even after a long training process between the growth phase and the pruning phase. Leveraging the growth policy, the model is able to recover quickly from the loss caused by pruning (the spiking in Fig. 7).

Robustness of the seed

The performance of CGaP is stable under the variation of the initial seeds. To prove this, we scan several seeds in different size and present the variation in accuracy and inference model size. The structure of 6 scanned seeds is listed in Table V. Each seed has a different number of filters in each layer, e.g., seed ‘2’ has 2 filters in block conv1. The size of the seeds varies from 0.01M to 0.53M. Fig. 10 presents the final model size and the number of growth of each seed. A larger seed leads to a larger final model but requires fewer iterations of growth to reach the intended model size. Generally speaking, there is a trade-off between the inference accuracy and the model size. Though the seed varies a lot from each other, the final accuracy is quite robust, as listed in the ‘Accuracy’ row in Table V. It is worth mentioning that, even though the seed ‘2’ degrades the accuracy of $0.69\%$ from baseline, the inference model size is only 2.4M, significantly smaller than the baseline size (20.4M).

Robustness of the hyper-parameters

CGaP is conditioned on a set of hyper-parameters to achieve optimal performance, while it is stable under the variation of these hyper-parameters. Empirically, we leverage the following experience to perform parameter optimization: a smaller growth rate $\beta$ for a larger seed and vice versa; threshold $\tau_{capa}$ is set based on the user’s intended model size; a smaller $f_{growth}$ for a complicated dataset and vice versa; a relatively greedy growth (larger $\beta$ and $f_{growth}$) prefers a larger noise $\mu$ but smaller $\sigma$ to push the model away from sticking at a local minimum. Tuning of the pruning ratio of each layer is in a similar manner to that of the other pruning works [15] [16].

In particular, we scan 121 combinations of the scaling factor $\sigma$ and noise $\mu$ in the range [0.0, 1.0] with the step=0.1 and provide the following discussion. For VGG16 on CIFAR-10, the accuracy of several corner cases are $90\%$ ($\mu$=1, $\sigma$=0, which is a case of random initialization), $89\%$ ($\mu$=1, $\sigma$=1), $84\%$ ($\mu$=0, $\sigma$=1, which is another case of mimicking its neighbor without scaling) and $10\%$ ($\mu$=0, $\sigma$=0, the training is invalid in this case), $93\%$ ($\mu$=0, $\sigma$=0, which is another case of mimicking its neighbor with scaling), $88\%$ ($\mu$=0.5, $\sigma$=0, which is another case of random initialization). The best accuracy of $93.6\%$ is under $\mu$=0.1, $\sigma$=0.5. The combinations in the zone that $\mu\in[0,0.5]$ and $\sigma\in(0,0.5]$ always provide >$92\%$ accuracy. To summarize, $\sigma$ impacts more than $\mu$ as $\mu$ is relatively small; $\sigma$ should not be too large and 0.5 is safe for future tasks and networks; adding a noise improves the accuracy (like from $93\%$ to $93.6\%$) as it prevents local minimum; inheriting from the neighbor is more efficient than randomly initializing since the network is able to resume the learning right after the growth.

VIII Conclusion and Future Work

Modern DNNs typically start training from a fixed and over-parameterized network, which leads to redundancy and is lack of structural plasticity. We propose a novel dynamic training algorithm, Continuous Growth and Pruning, that initializes training from a small network, expands the network width continuously to learn important learning units and structures and finally prunes secondary ones. The effectiveness of CGaP depends on where to start and stop the growth, which learning unit (filter and neuron) should be added, and how to initialize the newborn units to ensure model convergence. Our experiments on benchmark datasets and architectures demonstrate the advantage of CGaP on learning efficiency (accurate and compact). We further validate the energy and latency efficiency of the inference model generated by CGaP on FPGA performance simulator. Our approach and analysis will help shed light on the development of adaptive neural networks for dynamic tasks such as continual and lifelong learning.

Acknowledgment

This work was supported in part by C-BRIC, one of six centers in JUMP, a Semiconductor Research Corporation (SRC) program sponsored by DARPA. It was also partially supported by National Science Foundation (NSF) under CCF #1715443.