On Correlation of Features Extracted by Deep Neural Networks

TL;DR

This paper investigates how network size, activation functions, and initialization influence the tendency of deep neural networks to extract redundant features, using clustering methods on features from MLP and CNN models.

Contribution

It identifies key factors like network size and activation functions that promote feature redundancy in DNNs, providing insights into model overparameterization.

Findings

Network size and activation functions significantly increase feature redundancy.

Redundant features can be estimated via hierarchical clustering based on cosine distances.

Redundancy patterns are demonstrated on MNIST and CIFAR-10 datasets.

Abstract

Redundancy in deep neural network (DNN) models has always been one of their most intriguing and important properties. DNNs have been shown to overparameterize, or extract a lot of redundant features. In this work, we explore the impact of size (both width and depth), activation function, and weight initialization on the susceptibility of deep neural network models to extract redundant features. To estimate the number of redundant features in each layer, all the features of a given layer are hierarchically clustered according to their relative cosine distances in feature space and a set threshold. It is shown that both network size and activation function are the two most important components that foster the tendency of DNNs to extract redundant features. The concept is illustrated using deep multilayer perceptron and convolutional neural networks on MNIST digits recognition and CIFAR-10 dataset, respectively.

Tables

Table 1. Table 1: Performance of VGG models on Cifar-10 dataset. τ 𝜏 \tau is the threshold of similarity.

VGG		${\overline{n}}_r$ (%)
Model	# Conv Layers	$\tau =0.4$	$\tau =0.5$	$\tau =0.6$	$\tau =0.7$	test accuracy (%)
VGG-11	8	34.0	24.1	17.7	12.8	92.09
VGG-13	10	37.8	26.9	19.1	12.9	93.65
VGG-16	13	58.8	52.6	45.5	37.2	93.51
VGG-19	16	72.4	68.3	64.5	60.3	93.24

Equations

$$\begin{array}{r}Cosine({\varphi }_1,{\varphi }_2)=\frac{<{\varphi }_1,{\varphi }_2>}{\parallel {\varphi }_1\parallel \parallel {\varphi }_2\parallel }\end{array}$$

$$\begin{array}{r}{\Omega }^{(l)}={{\mathbf{\Phi }}^{\mathbf{T}}}^{(l)}{\mathbf{\Phi }}^{(l)}\end{array}$$

$$\begin{array}{rl}\overline{SI{M}_C}(C_a,C_b)& =\frac{{\sum }_{{\varphi }_i\in C_a,{\varphi }_j\in C_b}Cosine({\varphi }_i,{\varphi }_j)}{|C_a|\times |C_b|}>\tau \\ & a,b=1,...n_l^{\prime };a\ne b;i=1,...|C_a|;\\ & j=1,...|C_b|;andi\ne j\end{array}$$

$$\begin{array}{rl}{n}_r^{(l)}& =n_l^{\prime }-n_f^{(l)}\end{array}$$

$$\sigma (\mathbf{z})=\frac{1}{1+e^{-\mathbf{z}}}$$

$$Tanh(\mathbf{z})=\frac{e^{\mathbf{z}}-e^{-\mathbf{z}}}{e^{\mathbf{z}}+e^{-\mathbf{z}}}$$

$$\begin{array}{r}ReLU(\mathbf{z})=\text{max}(0,\mathbf{z})\end{array}$$

$${ELU(\mathbf{z})=\Bigg{\{}\begin{array}[]{l l}\mathbf{z}&\quad\mathbf{z}>0\\ \\ \alpha(e^{\mathbf{z}}-1)&\quad||\mathbf{z}||\leq 0\end{array}}$$

$${SeLU(\mathbf{z})=\lambda\Bigg{\{}\begin{array}[]{l l}\mathbf{z}&\quad\mathbf{z}>0\\ \\ \alpha e^{\mathbf{z}}-\alpha&\quad||\mathbf{z}||\leq 0\end{array}}$$

$$\kappa =\sqrt{\frac{6}{n_l^{\prime }+n_{l+1}^{\prime }}}$$

Full text

Keywords: Deep learning, feature correlation, feature clustering, cosine similarity, feature redundancy, deep neural networks.

1 Introduction

DNNs have become ubiquitous in a wide range of applications ranging from computer vision [1, 2, 3, 4] to speech recognition [5, 6, 7] and natural language processing [8, 9]. Over the past few years, the general trend has been that DNNs have grown deeper and wider, amounting to huge increase in their size. The number of parameters in DNNs is usually very large and no constraints are generally placed on the data and/or the model, hence offering possibility to learn very flexible and high-performing models [10, 11]. However, this flexibility may hinder their scalability and practicality due to very high memory/time requirements, and may lead to extracting highly redundant parameters with risk of over-fitting [12, 13].

A number of studies have shown that a significant percentage of features extracted by DNNs are redundant [14, 15, 16, 17, 18, 19, 20, 21]. As demonstrated in [14], a fraction of the parameters is sufficient to reconstruct the entire network by simply training on low-rank decompositions of the weight matrices. To this end, Optimal Brain Damage [22] and Optimal Brain Surgeon [23] exploit second-order derivative information of the loss function to localize unimportant parameters. HashedNets use a hash function to randomly group weights into hash buckets, so that all weights within the same hash bucket share a single parameter value for pruning purposes [24]. Redundant features have also been localized and pruned using simple thresholding mechanism [25].

Instead of localizing the redundant neurons in a fully-connected network, [26] compresses a trained model by identifying a subset of diverse neurons. Redundant feature maps are removed from a well trained network using particle filtering to select the best combination from a number of randomly generated masks [27]. The importance of features has also been ranked based on the sum of their absolute weights [28]. With the assumptions that features are co-dependent within each layer, [29] groups features in hierarchical order. Driven by feature map redundancy, [30] factorizes a layer into $3\times 3$ and $1\times 1$ combinations and prunes redundant feature maps.

These observations that DNNs are prone to extracting redundant features evidently suggest and reinforce our hypothesis that much of the information stored within DNN models may be redundant. In addition, large number of parameters also translates to model’s tendency to overfitting, if trained on limited amount of data. Some of the problems associated with over-parameterization have been previously addressed via model compression [28, 31], removal of unnecessary weights [22, 23], and regularization [32, 33]. These heuristics for eliminating redundancy more often than not deteriorate the performance of the compressed model. The open question still remains: how to obtain best compact and efficient models that are free of redundancy?

Knowing the level of redundancy in models could be useful for two main reasons. First, inference-cost-efficient models can be built via pruning with small deterioration of prediction accuracy [28, 25]. This is important in practice because optimal architecture are unknown. However, pruning should enable smaller model to inherit knowledge from a larger model. Since learning a complex function directly by small suboptimal model might result in its poor performance, it is therefore necessary to first learn a task with model many parameters and to follow with pruning redundant and less important features [27]. This is particularly important for porting deep learning models to resource limited portable devices. Secondly, information about the level of redundancy in models can be used for feature diversification in order to optimize their performance since the adverse effect of redundancy in DNNs has been shown in [34, 15, 15, 12, 35].

The problem addressed in this work is three-fold: (i) we investigate the impact of modules of DNNs such as width and depth of the network, activation function, and parameter initialization on extraction of redundant features by DNNs (both fully-connected and convolutional), (ii) we estimated the number of redundant features by adapting hierarchical agglomerative clustering algorithm, and (iii) we show experimentation in order to obtain insight about which configurations (network size/activation function/parameter initialization) provide better performance tradeoff. The paper is structured as follows: Section II introduces the network configurations and the notation used in the paper. Section III introduces the notion of feature redundancy in DNN and its estimation. Section IV discusses the experimental designs and present the results. Finally, conclusions are drawn in the last section.

2 Network Configurations

Notations and network configurations in the paper in context of convolutional and fully-connected layer are briefly and separately highlighted below:

2.0.1 Convolutional layer:

By letting $n^{\prime}_{l}$, $h_{l}$, and $w_{l}$, denote the number of channels, height and width of input of the $l^{th}$ layer, respectively, input $x_{l}\in\mathbb{R}^{p}$ is transformed by a layer into output $x_{l+1}\in\mathbb{R}^{q}$, where $x_{l+1}$ serves as the input in layer $l+1$. Since the layer is convolutional, $p$ and $q$ are given as $n^{\prime}_{l}\times h_{l}\times w_{l}$ and $n^{\prime}_{l+1}\times h_{l+1}\times w_{l+1}$, respectively. A convolutional layer convolves $x_{l}$ with $n^{\prime}_{l+1}$ $3D$ features $\chi\in\mathbb{R}^{n^{\prime}_{l}\times k\times k}$, resulting in $n^{\prime}_{l+1}$ output feature maps. Each $3D$ feature consists of $n^{\prime}_{l}$ $2D$ kernels $\zeta\in k\times k$. Unrolling and combining all features into a single kernel matrix $\mathbf{W}\in\mathbb{R}^{z\times n^{\prime}_{l+1}}$ where $z=k^{2}n^{\prime}_{l}$. The $ith$ feature in layer $l$ is denoted by $\mathbf{w}^{(l)}_{i}$, i=1,…$n^{\prime}_{l}$ and each $\mathbf{w}^{(l)}_{i}\in\mathbb{R}^{z}$ corresponds to the $i$-th column of the kernel matrix $\mathbf{W}^{(l)}=[\mathbf{w}^{(l)}_{1},\;\;...\mathbf{w}^{(l)}_{n^{\prime}_{l}}]\in\mathbb{R}^{z\times n^{\prime}_{l+1}}$.

2.0.2 Fully-connected layer:

In the case of a fully-connected layer, $p$ and $q$ denote $n^{\prime}_{l}h_{l}w_{l}\times 1$ and $n^{\prime}_{l+1}\times 1$, respectively. A layer operation involves only vector-matrix multiplication with kernel matrix $\mathbf{W}\in\mathbb{R}^{z\times n^{\prime}_{l+1}}$, where $z=n^{\prime}_{l}h_{l}w_{l}$. Also for fully-connected layer, the $ith$ feature in layer $l$ is denoted by $\mathbf{w}^{(l)}_{i}$, i=1,…$n^{\prime}_{l}$ and each $\mathbf{w}^{(l)}_{i}\in\mathbb{R}^{z}$ corresponds to the $i$-th column of the kernel matrix $\mathbf{W}^{(l)}=[\mathbf{w}^{(l)}_{1},\;\;...\mathbf{w}^{(l)}_{n^{\prime}_{l}}]\in\mathbb{R}^{z\times n^{\prime}_{l+1}}$.

3 Estimating the number of redundant features

Correlation between two features can be computed by evaluating the cosine similarity measure between them as given in (1):

[TABLE]

where $<\phi_{1},\phi_{2}>$ is the inner product of two arbitrary normalized feature vectors $\phi_{1}$ and $\phi_{2}$; $\phi_{i}=\nicefrac{{w_{i}}}{{\sqrt{||w_{i}||^{2}}}}$ and $i=1,2$. The similarity between two feature vectors corresponds to the correlation between them, that is, the cosine of the angle between them in feature space. Since the entries of feature vectors can take both negative and positive values, $Cosine(\phi_{1},\phi_{2})$ is bounded by [-1,1]. It is 1 when $\phi_{1}$=$\phi_{2}$ or when $\phi_{1}$ and $\phi_{2}$ are identical. $Cosine(\phi_{1},\phi_{2})$ is -$1$ when the two vectors are in exact opposite direction. The two feature vectors are orthogonal in weight space when $Cosine$ is [math].

The evaluation of pairwise feature similarities $\Omega^{(l)}$ for a given layer $l$ can be vectorized to reduce the computational overhead. By letting $\mathbf{\Phi}=[\phi^{(l)}_{1},\;\;...\phi^{(l)}_{n^{\prime}_{l}}]\in\mathbb{R}^{z\times n^{\prime}_{l}}$ contain $n^{\prime}_{l}$ normalized feature vectors $\phi_{i}$ as columns, each with $z$ elements corresponding to connections from layer $l-1$ to $i^{th}$ neuron of layer $l$, then the pairwise feature similarities $\Omega^{(l)}$ for a given layer $l$ is given as

[TABLE]

$\Omega^{(l)}\in\mathbb{R}^{n^{\prime}\times n^{\prime}}$ contains the inner products of each pair of columns $i$ and $j$ of $\mathbf{\Phi}^{(l)}$ in each position $i$,$j$ of $\Omega$ in layer $l$. It is remarked that $\Omega^{(l)}$ can be used to roughly estimate the number of redundant features in layer $l$. In this work, we utilize a suitable agglomerative similarity testing/clustering algorithms to estimate the number of redundant features.

Based on a comparative review, a clustering approach from [36, 37] has been adapted and reformulated for this purpose. By starting with each feature vector $\phi_{i}$ as a potential cluster, agglomerative clustering is performed by merging the two most similar clusters $C_{a}$ and $C_{b}$ as long as the average similarity between their constituent feature vectors is above a chosen cluster similarity threshold denoted as $\tau$ [38, 39]. The pair of clusters $C_{a}$ and $C_{b}$ exhibits average mutual similarities as follows:

[TABLE]

It must be noted that the definition of similarity in (3) uses the graph-based-group-average technique, which defines cluster proximity/similarity as the average of pairwise similarities of all pairs of features from different clusters. This work also considers other similarity definitions such as the single and complete links. Single link defines cluster similarity as the similarity between the two closest feature vectors that are in different clusters. On the other hand, complete link assumes that cluster proximity is the proximity between the two farthest feature vectors of different clusters. In this work, experiments based on average proximity were reported because of their superior performance. It is strongly believe that graph-based-group-average performs better because all cluster members contributed in the decision making process.

The objective of the clustering algorithm is to discover $n_{f}$ features in the set of $n^{\prime}$ original weight vectors (or simply features), where $n_{f}\leq n^{\prime}$. Upon detecting these distinct $n_{f}$ clusters, a representative feature from each of these $n_{f}$ clusters is randomly sampled without replacement and the remaining features in that cluster are tagged as redundant. The number of redundant features in a particular layer $l$ is then estimated as in (4).

[TABLE]

To illustrate the impact of activation functions and weight initializations on DNNs’ susceptibility to extracting redundant features, we considered five popular activation functions (namely: Sigmoid, Tanh, ReLU, ELU, and SeLU) and five weight initializations. The activation functions considered are briefly highlighted below. Given any finite dimensional vector $\mathbf{z}$ for which activation function is to be computed for, the following four activation functions are defined as follows:

Sigmoid:

[TABLE] 2. 2.

Hyperbolic Tangent:

[TABLE] 3. 3.

Rectified Linear Units [40]:

[TABLE] 4. 4.

Exponential Linear Units [41]:

[TABLE]

where $\alpha$ is an hyperparameter that controls the value at which ELU activation function saturates for inputs with negative values. 5. 5.

Scaled Exponential Linear Units [42]:

[TABLE]

where $\lambda>1$ and $\alpha$ are derived from the input. SeLU also uses a custom weight initialization with zero mean and standard deviation of $\sqrt{\nicefrac{{1}}{{\text{size of input vector}}}}$.

Also, the five popular weight initialization heuristics considered are briefly described as follows:

random_uniform: initializes weights between $-0.05$ and $0.05$ from a uniform distribution 2. 2.

orthogonal [43]: initializes weight through the generation of orthogonal matrix with scalar gain factor $g$ (chosen to be 1.0 in our experiments), where gain is a multiplicative factor that scales the orthogonal matrix 3. 3.

xavier [44]: is also known as Xavier uniform initialization and it initializes weights within [-$\kappa$ $\kappa$] from uniform distribution where $\kappa$ is given as:

[TABLE]

where $n^{\prime}_{l}$ is the number of input units and $n^{\prime}_{l+1}$ is the number of output units. 4. 4.

he_normal [45]: initializes weight with samples drawn from a truncated normal distribution centered around [math] with standard deviation of $\sqrt{\frac{2}{n^{\prime}_{l}}}$ 5. 5.

lecun_normal [46]: initializes weight with samples drawn from a truncated normal distribution centered around [math] with standard deviation of $\sqrt{\frac{1}{n^{\prime}_{l}}}$.

4 Experiments

In the first set of experiments we considered a fully-connected network trained and evaluated on MNIST dataset of handwritten digits. All experiments were performed on Intel(r) Core(TM) i7-6700 CPU @ 3.40Ghz and a 64GB of RAM running a 64-bit Ubuntu 14.04 edition. The software implementation has been in Pytorch library 111http://pytorch.org/ on two Titan X 12GB GPUs and the feature clustering was implemented in SciPy ecosystem [47]. The standard MNIST dataset has 60000 training and 10000 testing examples. Each example is a grayscale image of an handwritten digit scaled and centered in a 28 $\times$ 28 pixel box. Adam optimizer [48] with batch size of 128 was used to train the model for 200 epochs.

The number of redundant features was computed as in (4) after the models have been fully trained. Figures 1 a,b,c, and d show the performance of multilayer perceptron with one, two, three, and four hidden layer(s), respectively. The average number of redundant features across all layers of the network is denoted as $\bar{n}_{r}$. It can be observed in Figure 1 that both width (number of hidden units per layer) and depth (number of layers in the network) increase $\bar{n}_{r}$. As the number of hidden units per layer increases, $\bar{n}_{r}$ grows almost linearly. Also, the higher the number of hidden layers in a network, the higher the average number of redundant features extracted and the higher the average feature pairwise correlations. For instance, the network with one hidden layer and $100$ hidden units does not have any feature pair correlated above $0.4$. However, as the depth increases (for two or more hidden layers) more feature pairs have correlation above $0.4$. This observation is similar for other hidden layer sizes ($200$, $300$, $500$, $700$, and $1000$) and depth. In particular, as can be observed in Figure 1d that many feature pairs in deep multilayer network (with four hidden layers) are almost perfectly correlated with cosine similarity of $0.9$ even with just $100$ hidden units per layer.

In the second set of experiments, we also used the MNIST dataset to see the impact of activation function and number of layers in DNNs on susceptibility to redundant feature extraction. We considered five popular activation functions namely: Sigmoid, Tanh, ReLU, ELU, and SeLU. In order to focus on the effect of activation function and number of layers, we fixed the width (number of hidden units) of the network for all layers and was set to $1000$. For all networks, the weights were initialized randomly by sampling from normal distribution with zero mean and standard deviation of 0.01. Pairwise feature similarity was measured at thresholds $\tau=0.5$, $0.6$, and $0.7$. As shown in Figure 2 for all thresholds, sigmoid, ELU, and SeLU have higher tendency to extract redundant features than those of Tanh and ReLU. In fact, it was observed that the average number of redundant feature extracted for ReLU and Tanh did not increase as the number of layers increased. In fact, as can be observed in Figure 2b, the redundancy slightly decreases for both ReLU and Tanh as opposed to Sigmoid, ELU, and SeLU where it is almost always increasing.

Also, Figure 3c reinforces the observation that ReLU activation is able to outperform both sigmoid and tanh activations in Figures 3a and b for very deep networks and exhibits inherent nature to extract more diverse features. It can be observed in Figures 3 that ReLU benefits from both width and depth than its counterparts. As width and depth increase, the performance of tanh deteriorates while that of sigmoid heavily fluctuates. Deep multilayer network was also evaluated based on the distribution of data in high level feature space. In this regard, t-distributed stochastic neighbor embedding (t-SNE) [49] was used to project and visualize the last hidden activations of single-hidden-layer and four-hidden-layer networks using Sigmoid, SeLU, Tanh, and ReLU activations into 2D. The projections of single layer networks and that of four-layer networks are as shown in Figures 4 and 5, respectively. The t-SNE projections show that networks with four hidden layers have clustered activations compared to that of a single layer resulting in within class holes. This is observation is pronounced for Sigmoid and SeLU activations.

In the third set of experiments on MNIST, five weight initialization heuristics were tested and the width of the network per layer was also fixed and set to $1000$. Sigmoid was used in this set of experiments and only the initialization method and number of layers were varied. As shown in Figure 6, all weight initializations for shallow networks have similar tendency to extract redundant features. As the number of layers increases, however, he_normal [45] extracts less redundant features than all its counterparts. This observation is relatively consistent for thresholds $\tau=0.5$, $0.6$, and $0.7$ as shown in Figures 6a, b, and c, respectively. This might explain why it usually outperforms other initialization methods in most vision task.

In the last set of experiments, we trained deep convolutional neural networks (VGG-11,13,16,19) on CIFAR-10 dataset to see how depth is impacting redundant feature extraction. VGG architecture [1] is a high capacity network designed originally for ImageNet dataset. We used a modified version of the VGG network architecture, which has $c$ convolutional layers and 2 fully connected layer. Constant $c$ in VGG-11, VGG-13, VGG-16, and VGG-19 are $8$, $10$, $13$, and $16$, respectively. In the modified version of VGG architectures, each layer of convolution is followed by a Batch Normalization layer [50]. CIFAR-10 dataset contains a labeled set of 60,000 32x32 color images belonging to 10 classes: airplanes, automobiles, birds, cats, deer, dogs, frogs, horses, ships, and trucks. The dataset is split into $50000$ and $10000$ training and testing sets, respectively. Our baseline model was trained for 300 epochs, with a batch-size of 128 and a learning rate 0.1. The learning rate was reduced by a factor of 10 at 150 and 250 epochs.

As shown in Table 1, the average number of redundant fetaures across all layers ($\bar{n}_{r}$) also increases as number of convolutional layers increases. It can be observed that with 13 layers of convolution, the performance of the model starts deteriorating and the percentage of redundant feature increases by more than $21\%$ for all $\tau$ values considered. Another crucial observation is that networks (VGG-11 and VGG-13) with 8 and 10 convolutional layers have relatively similar level of redundancy, especially for $\tau=0.7$. This means, in relative terms, that both VGG-11 and VGG-13 have smaller degree of overfitting compared to VGG-16 and VGG-19 as reflected in their test accuracies. This may suggest a strong correlation between the level of redundancy in a model and its generalization. It must be noted that the test error of VGG-11 is higher than its counterparts; we believe that perhaps VGG-11 with 8 layers of convolution is somehow underfitting the CIFAR-10 dataset.

5 Conclusion

This paper shows how size, choice of activation function, and weight initialization impact redundant feature extraction of deep neural network models. The number of redundant features is estimated by agglomerating features in weight space according to a well-defined similarity measure. Experiments were carried out using benchmark datasets and select models. The results show that both width and depth strongly correlate with redundant feature extraction. It is also established that the wider and deeper a network becomes, the higher is its tendency to extract redundant features. It has also been empirically shown on select examples that ReLU activation function enforces extraction of less redundant features in comparison with other activations function considered. Also, the he_normal initialization heuristic presented in [45] offers the advantange of extracting more distinct features for deep networks than other popular initialization heuristics considered. We illustrated the concept using fully-connected and convolutional neural networks on MNIST handwritten digits and CIFAR-10.