Hierarchical 1D CNN-GRU Architecture

• Hierarchical 1D CNN-GRU topology is a neural architecture that combines stacked 1D convolutional blocks with a GRU to capture both local and long-term temporal dependencies.
• It uses Local Feature Acquiring Blocks (LFABs) with dilated convolutions for fine-grained spectral-temporal extraction, feeding into a GRU that models global context.
• The design supports robust speech emotion recognition and is adaptable for analyzing other types of temporally structured data.

A hierarchical 1D CNN-GRU topology is a multi-stage neural architecture that integrates sequentially stacked one-dimensional convolutional blocks with a @@@@2@@@@ (GRU) for the purpose of modeling local and long-term temporal dependencies in input data. The topology is characterized by its use of Local Feature Acquiring Blocks (LFABs)—specialized dilated 1D convolution networks—followed by a Global Feature Acquiring Block (GFAB) implemented with a high-dimensional GRU, terminating in fully connected layers for classification. This design was developed to capture spectral–temporal patterns and utterance-level dynamics, providing a compact framework for tasks such as speech emotion recognition (Ahmed et al., 2021).

1. Architectural Design: Staging and Data Flow

The topology accepts a fixed-dimensional input feature vector per utterance. Specifically, the architecture described in (Ahmed et al., 2021) uses a $155 \times 1$ feature vector, composed of 13 Mel-frequency cepstral coefficients (MFCCs), 128 log-Mel bins, 12 chroma, one zero-crossing rate (ZCR), and one root mean square (RMS) energy value, extracted from speech samples. The network is structured as follows:

1. Stage 1: Seven sequential LFABs, each a dilated 1D convolutional block with batch normalization, ReLU activation, dropout, and max pooling except in the final block.
2. Stage 2: A single GRU layer (GFAB) with 512 units, outputting the final state only, followed by dropout.
3. Stage 3: Two consecutive dense layers (128, then 64 nodes, both with ReLU and dropout), culminating in classification via a softmax output.

Data transitions through LFABs, progressively aggregating and summarizing local features. The output tensor from the final LFAB is supplied as a time-ordered sequence directly (no flattening) to the GRU, whose hidden state encodes the global context for high-level classification. Subsequent dense layers condense this information for final decision boundaries.

2. Local Feature Acquiring Blocks (LFABs)

Each LFAB is a convolutional subnetwork designed to prioritize local feature extraction. Key parameters across all LFABs:

• Conv1D Layer: Kernel size: 8, Stride: 1, Padding: 'same', Dilation rate: 1.
• Filter progression: $F_i$ per block: 256, 256, 256, 128, 128, 128, 64.
• Regularization: KernelRegularizer = L2(0.01), BiasRegularizer = L2(0.01).
• BatchNorm: Momentum = 0.99, Epsilon = $1 \times 10^{-3}$.
• Activation: ReLU post-batchnorm.
• Dropout: 0.25 in LFABs 1–6, 0.50 in LFAB 7.
• Max-Pooling: pool_size = 2, strides = 2 (in LFABs 1–6 only).

Output from each Conv1D is

$y[t] = \sum_{k=0}^{K-1} x[t - d k] \cdot w[k]$

where $K=8$ (kernel size), $d=1$ (dilation rate), $w[k]$ (kernel weights). The stacking of seven LFABs with successive pooling expands the receptive field; after six pools, context spans approximately $8 \times 2^6 = 512$ time-steps, corresponding to a comprehensive summary of the initial input sequence (Ahmed et al., 2021).

3. Global Feature Acquiring Block (GFAB): GRU Integration

The output tensor from the seventh LFAB, of shape (batch_size, time_steps', 64), directly enters a GRU with 512 hidden units. Key specifics:

• Unidirectional GRU: units = 512, return_sequences = False.
• Dropout: 0.0 input/recurrent (paper specifies none), followed by Dropout(0.5) applied post-GRU output.
• Computation: Only the last hidden state is retained for downstream processing.

GRU cell update equations at time $t$: $z_t = \sigma(W_z [h_{t-1}, x_t] + b_z)$

$r_t = \sigma(W_r [h_{t-1}, x_t] + b_r)$

$$\tilde h_t = \tanh(W_h [r_t \odot h_{t-1}, x_t] + b_h)$$

$$h_t = (1 - z_t) \odot h_{t-1} + z_t \odot \tilde h_t$$

with $\sigma$ the logistic sigmoid and $\odot$ the element-wise product. The GRU models long-range dependencies in the compressed, high-level sequence, focusing on prosody, intonation, and phrase contours within the utterance.

4. Classification Layers and Output

After dropout on the GRU output, the model transitions to two fully connected (dense) layers:

• First Dense Layer: 128 units, ReLU activation, Dropout(0.5).
• Second Dense Layer: 64 units, ReLU activation, Dropout(0.5).
• Output Layer: Dense(num_classes), softmax activation.

These layers serve dual functions: fusing global representations across the entire utterance and preparing a fixed-length embedding suitable for categorical decision via softmax. This sequence allows final classification to directly reflect both local and global temporal cues.

5. Hyperparameterization and Training Regimen

For optimization, the model applies:

• Adam optimizer: lr = 0.001, β₁ = 0.9, β₂ = 0.999, $\epsilon = 10^{-7}$.
• Loss function: categorical_crossentropy.
• Batch size: 32.
• Epochs: up to 1000 (early stopping implemented as needed).
• Regularization: $L_2 = 0.01$ for all convolutional kernels and biases; dropout as previously detailed.

This configuration is engineered to minimize overfitting and maximize generalization performance on benchmark emotion recognition datasets: TESS, EMO-DB, RAVDESS, SAVEE, and CREMA-D.

6. Functional Significance: Local and Global Temporal Modeling

The hierarchical CNN-GRU arrangement enables the network to learn high-resolution, short-range spectral–temporal patterns through stacked 1D convolutions and pooling, while the GRU layer functions as a mechanism for aggregating and modeling utterance-level, long-term dependencies. The step-wise reduction in temporal resolution via pooling followed by global context aggregation in the GRU explains its effectiveness in speech emotion recognition tasks, specifically in capturing both instantaneous and holistic prosody information.

A plausible implication is that this hierarchy is suitable for any application requiring fine-grained local feature extraction with subsequent global sequence modeling, especially where high-dimensional, temporally structured data is present. The architecture outperforms baseline non-hierarchical models in weighted average accuracy across multiple datasets (Ahmed et al., 2021).

7. Contextualization and Comparative Position

The hierarchical 1D CNN-GRU topology is one variant within an ensemble of architectures developed for speech emotion recognition (Ahmed et al., 2021). When compared with LFAB-only and LFAB-LSTM designs, the inclusion of GRU as a global summarizer yields improved modeling of utterance-level dynamics. The design choices—fixed kernel size, consistent regularization, staged dropout, and absence of recurrent dropout—reflect a deliberate balance of complexity, capacity, and robustness.

This model aligns with contemporary trends that couple convolutional extraction of local features with recurrent modeling of sequence dependencies. The execution of data augmentation (injecting Additive White Gaussian Noise, pitch shifting, and stretching) further positions this architecture within current practices for robust speech analysis.

A plausible extension is the application of this hierarchical pattern to other sequential data modalities beyond speech, where similar dual-scale feature hierarchies are beneficial.