Towards Advanced Speech Signal Processing: A Statistical Perspective on Convolution-Based Architectures and It’s Applications

1. Introduction

In this subsection, the principle of convolution and its application to the modification of a speech signal are explained.

1.1. Mathematical Foundation for Convolution

Most broadly, convolution is the mathematical process of compounding two functions to produce a third function, which reflects the influence of one effect on the other—how changing one alters the form of the other. Convolution is effective for analyzing linear time-invariant (LTI) systems and is applied in a wide range of engineering fields, such as speech processing [1].

$$(f\ast g)\left(t\right)={\int }_{-\infty }^{\infty }f\left(\tau \right)·g(t-\tau )d\tau$$

(1)

Where $(f\ast g)\left(t\right)$ is the convolution of $f\left(\tau \right)$ and $g(t-\tau )$, where both functions overlap in all time.

The discrete convolution formula for sequences $\left\{f\right[k\left]\right\}$ and $\left\{g\right[k\left]\right\}$ is as follows:

$$(f\ast g)\left[n\right]=\sum _{k=-\infty }^{\infty }f\left[k\right]·g[n-k].$$

(2)

Equation (2) defines the discrete convolution, which sums products of $f\left[k\right]$ and shifted versions of $g\left[k\right]$ for all integers k.

If $x\left(t\right)$ is the input of the system and $h\left(t\right)$ is its impulse response, then $Y\left(t\right)$ has the following form:

$$Y\left(t\right)=(x\ast h)\left(t\right)={\int }_{-\infty }^{\infty }x\left(\tau \right)·h(t-\tau )d\tau$$

(3)

This equation represents the output signal as a function of the input signal modified by the system’s impulse response.

There are several useful properties for signal processing analysis that convolutions possess. It is commutative, i.e., $f\ast g=g\ast f$; associative, i.e., $f\ast (g\ast h)=(f\ast g)\ast h$; and distributive over addition, i.e., $f\ast (g+h)=(f\ast g)+(f\ast h)$. These characteristics allow the reduction and analysis of complex systems.

1.2. Introduction to Speech Signal Processing

Speech signal processing involves analyzing speech signals and developing techniques to process them for effective communication between humans and machines. Speech signals are 1D, time-varying signals that are a manifestation of acoustic description of human language [1]. These signals are generally (a) non-stationary, (b) large dynamic range, and (c) rich spectral content, which can be challenging to analyze.

In speech signal processing, convolution plays an important role. When a speech signal $s\left(t\right)$ is transmitted or recorded in a communication channel, it is changed by the channel impulse response $h\left(t\right)$. Received signal $r\left(t\right)$ can be expressed as a convolution between speech signal and channel impulse response:

$$R\left(t\right)=(s\ast h)\left(t\right)={\int }_{-\infty }^{\infty }s\left(\tau \right)·h(t-\tau )d\tau$$

(4)

This equation models the interaction between the speech signal and the channel, incorporating effects such as echo, reverberation, and attenuation.

If noise $n\left(t\right)$ is added, the received signal becomes:

$$r\left(t\right)=s\left(t\right)\ast h\left(t\right)+n\left(t\right)$$

(5)

The existence of noise makes it difficult to reconstruct the priori speech signal.

Convolution is also employed for feature extraction in the speech domain, such as calculating the frequency content of speech. The filtered speech signal can be convolved with a sequence of filters to realize time-frequency representations such as short-time Fourier transform, which are important for speech recognition and speaker labeling [1,13]. These methods derive articulatory and prosodic features of speech that are of paramount importance to speech decoding of spoken language.

Further, speech signal heterogeneity—that is, heterogeneity of the signals arising from speakers, accents, speech rate, and emotional states—introduces the challenge of complexity. Convolutional approaches must account for this heterogeneity. Yet, the issues, e.g., background noise, reverberation and real-world speech signal mixing, continue to be problems. Convolutional approaches, augmented with statistical signal processing, is an active research area for achieving robustness and performance in speech processing systems [9,19]. These methods are also the basis of developments in voice-based technology, automatic transcription and voice biometrics.

1.3. Convolution-Based Architectures

Recent breakthroughs in deep learning have enabled deep and convolutional based architectures which address a variety of problems in speech signal processing. The 4 functional architectures investigated are Convolutional Neural Network (CNN), Conformers, Convolutional Recurrent Neural Network (CRNN), and Residual Networks (ResNets).

Figure 1. Convolution-Based Architectures.

Figure 1. Convolution-Based Architectures.

In these architectures, convolutional layers are used to successively extract features of speech signals. Convolutional neural networks (CNNs) apply convolutional layers for fast feature extraction, whereas Convolutional Complex Architectures (Conformers) apply convolution along with self-attention for the local and global relationships. CRNNs combine convolutional and recurrent layers to learn temporal dynamics, and ResNets exploit shortcut connections to build deeper architectures without performance overfitting. Collectively, these architectures increase the accuracy of speech signal processing, including in noisy and dynamic environments.

2. Convolution Based Architectures

2.1. Convolutional Neural Networks (CNNs)

Convolutional neural networks (CNNs) have almost universal relevance for the analysis of structured data, e.g., spectrograms, in vocal signal processing. In convolutional neural networks (CNNs) layers with trainable filters convolutional layers are employed to slide across the input data and learn local patterns. The one-dimensional convolution operation is written as follows with a temporal input sequence $x\left(t\right)$ and a convolution kernel $w\left(k\right)$:

$$y\left(t\right)=\sum _{k=-K}^{K}w\left(k\right)·x(t-k)$$

(6)

Output $y\left(t\right)$ is defined where temporal dependencies are encoded, which are the basis for efficient speech signal processing [3]. CNNs make use of two-dimensional convolutions in time and frequency, which are as follows when applied to spectrograms:

$$y(i,j)=\sum _{m=-M}^M\sum _{n=-N}^{N}W(m,n)·S(i-m,j-n),$$

(7)

where $S(i,j)$ is the spectrogram value at time i and frequency j, and $W(m,n)$ is a filter. This lets CNNs also learn the frequency features specific to speech recognition tasks [22].

Figure 2. Illustration of a CNN architecture in speech processing.

Figure 2. Illustration of a CNN architecture in speech processing.

Pooling layers, e.g., max pooling, downsample spatial resolution and retain global features (i.e., lead to higher translation invariance). Given a feature map $y(i,j)$, max-pooling over a window size $p\times q$ is defined as:

$$z(i,j)=\underset{0\le m<p}{max}\underset{0\le n<q}{max}y(i+m,j+n).$$

(8)

Batch normalization also stabilizes and speeds up training by normalizing layer outputs. For an activation a with mean $\mu$ and variance ${\sigma }^2$, the normalized output is:

$$\widehat{a}={\displaystyle \frac{a-\mu }{\sqrt{{\sigma }^2+ϵ}}},y=\gamma ·\widehat{a}+\beta ,$$

(9)

where $\gamma$ and $\beta$ are learnable parameters [4].

Categorical cross-entropy loss is the rule-of-thumb for CNN classification and is formulated as follows with the predicted probabilities ${\widehat{y}}_i$ and the associated true labels $y_i$:

$$\mathrm{Loss}=-\sum _{i=1}^C{y}_{i}log\left({\widehat{y}}_i\right)$$

(10)

where C denotes the number of classes. This loss function contributes to effective feature learning that can be applied to a few tasks, e.g., automatic speech recognition (ASR) [1].

The usefulness of CNNs as an engine for extracting hierarchical patterns from spectrograms has long been shown. Sainath and Parada [23] applied CNNs for noisy large vocabulary continuous speech recognition (LVCSR) and showed the model’s robust nature, while Abdel-Hamid et al. [22] demonstrated CNNs’ superiority in phoneme recognition. CNNs are useful for speaker ID and verification because CNNs are able to learn speaker-specific features [15].

CNNs are tractable for high-bandwidth communication systems since, from the statistical signal processing viewpoint, CNNs are naturally expressive for feature extraction from the perfect specification. Specifically, the signal processing efficiency was highlighted in the future 5G communication system [3,7].

2.2. Conformers

To achieve state-of-the-art results for Automatic Speech Recognition (ASR), Gulati et al. [1] proposed the Conformer architecture, which incorporates convolutional layers within the Transformer design to offer both local and global information concurrently. Transformers are not adaptive to local patterns—something CNNs are apt at capturing—even when they leverage self-attention to model long-range dependencies. The Conformer makes use of these inherent strengths by adding convolutional layers to Transformer blocks.

Each Conformer block’s forward pass is:

$$\begin{array}{cc}\hfill {\tilde{x}}_i& =x_i+{\displaystyle \frac{1}{2}}\mathrm{FFN}\left(x_i\right),\hfill \end{array}$$

(11)

$$\begin{array}{cc}\hfill x_i^{\prime }& ={\tilde{x}}_i+\mathrm{MHSA}\left({\tilde{x}}_i\right),\hfill \end{array}$$

(12)

$$\begin{array}{cc}\hfill x_i^{\prime \prime }& =x_i^{\prime }+\mathrm{Conv}\left(x_i^{\prime }\right),\hfill \end{array}$$

(13)

$$\begin{array}{cc}\hfill y_i& =\mathrm{Layernorm}\left(x_i^{\prime \prime }+{\displaystyle \frac{1}{2}}\mathrm{FFN}\left(x_i^{\prime \prime }\right)\right)\hfill \end{array}$$

(14)

where $x_i$ is the input to the i-th block. From the above setup, MHSA can learn long-range dependencies as well as short-range dependencies using the convolutional layers to refine local features [1].

In Conformer, the convolutional module extracts local dependencies that are necessary for audio processing. For an input sequence $s\left(t\right)$ and a filter W, the convolution operation is:

Figure 3. Conformer model architecture.

Figure 3. Conformer model architecture.

$$y\left(t\right)=\sum _{k=-K}^{K}W\left(k\right)·s(t-k)$$

(15)

where $y\left(t\right)$ captures local features like phonemes. Conformer employs depthwise separable convolutions to reduce parameter complexity. Depthwise convolution operates per channel:

$$\mathrm{DepthwiseConv}\left(x\right)=x\ast W_d,$$

(16)

followed by pointwise convolution to merge channels:

$$\mathrm{PointwiseConv}\left(x\right)=W_p·x$$

(17)

MHSA handles global dependencies and performs scaled dot-product attention. For query Q, key K, and value V, attention A is computed as:

$$A=\mathrm{softmax}\left({\displaystyle \frac{Q{K}^T}{\sqrt{d_k}}}\right)V,$$

(18)

where $d_k$ is the dimension of the keys, allowing the model to focus on different parts of the input sequence.

The FFN applies position-wise non-linear transformations, enhancing representational power. Given input x, the FFN is:

$$\mathrm{FFN}\left(x\right)=\sigma (W_2·\mathrm{ReLU}(W_1·x+b_1)+b_2)$$

(19)

where $W_1$ and $W_2$ are weights, $b_1$ and $b_2$ are biases, and $\sigma$ is an activation function, enabling complex relationship modeling within the sequence.

The Conformer’s convolution-augmented Transformer framework is consistent with statistical signal processing concepts, and employs both intrinsic local and extrinsic global statistical characteristics for efficient modelling of the speech signal. This balance has also resulted in better ASR performance due to lower Word Error Rates (WER) in the benchmarks [1,5].

2.3. Residual Networks (ResNet)

Residual Networks (ResNet), introduced by He et al. [25], address the vanishing gradient issue by introducing residual connections, where some information can go around layers. This skip connection allows stable learning in deep architectures and, hence, ResNet is powerful for complex hierarchical feature extraction tasks, e.g., speech, image processing [26].

Figure 4. ResNet architecture proposed in [31].

Figure 4. ResNet architecture proposed in [31].

In each residual block, the model learns a residual mapping instead of a direct transformation. Given an input x, the output of a residual block is:

$$y=f(x,\left\{W_i\right\})+x$$

(20)

where $f(x,\left\{W_i\right\})$ represents the operations within the residual block, typically consisting of two convolutional layers followed by batch normalization:

$$f(x,\left\{W_i\right\})=\mathrm{BatchNorm}\left(\mathrm{ReLU}\left(\mathrm{BatchNorm}(W_1·x)\right)\right)+W_2·x.$$

(21)

The skip connection x helps maintain gradient flow, addressing the vanishing gradient problem [27].

ResNet processes 2D spectrograms with rows representing frequency and columns representing time intervals. The convolution operation is defined as:

$$y[i,j]=\sum _{m=0}^{M-1}\sum _{n=0}^{N-1}W[m,n]·S[i-m,j-n]$$

(22)

where $S[i,j]$ is the spectrogram input at time i and frequency j, and W is the convolution kernel. This operation leverages local dependencies necessary for decoding serial audio data.

The residual connection across each block enables the model to learn "innovations" or new information $f(S,\left\{W_i\right\})$ while maintaining the original signal S:

$$y=f(S,\left\{W_i\right\})+S,$$

(23)

where S denotes the input spectrogram, and $f(S,\left\{W_i\right\})$ is the transformation within the block. This approach allows the model to capture both temporal and spectral correlations, improving its ability to map phoneme to prosodic information in applications like automatic speech recognition (ASR) and speaker identification [29].

The gradient of a layer L with output $y_L$ and loss $\mathcal{L}$ is preserved through the skip connection:

$${\displaystyle \frac{\partial \mathcal{L}}{\partial y_L}}={\displaystyle \frac{\partial \mathcal{L}}{\partial y_{L+1}}}·\left(1+{\displaystyle \frac{\partial f\left(y_L\right)}{\partial y_L}}\right).$$

(24)

where $f\left(y_L\right)$ is the residual mapping. This gradient stability allows deep ResNet architectures to learn discriminative, hierarchical features in sequential data such as audio [28,30].

2.4. Convolutional Recurrent Neural Networks (CRNNs)

Convolutional Recurrent Neural Networks (CRNNs) integrate Convolutional Neural Networks (CNNs) and Recurrent Neural Networks (RNNs), in particular Long Short-Term Memory (LSTM) units, to improve upon the use of both spatial and temporal dependencies in sequential data, e.g., audio spectrograms [11]. This architecture is particularly appropriate for problems that need to extract local features as well as long-range temporal dependencies.

Initially, CRNNs apply a series of convolutional layers to extract spatial features from an input spectrogram $S(i,j)$, where i and j denote the time and frequency dimensions. For each convolutional filter $W(m,n)$, the subsequent feature map $y(i,j)$ is:

$$y(i,j)=\sum _{m=-M}^M\sum _{n=-N}^{N}W(m,n)·S(i-m,j-n)$$

(25)

where M and N define the kernel size. Pooling layers, e.g., max pooling, are commonly used to downsample the spatial resolution, preserving the strongest features and minimizing computational complexity:

$$Z(i,j)=\underset{0\le m<p}{max}\underset{0\le n<q}{max}y(i+m,j+n)$$

(26)

where $p\times q$ is the pooling window size.

Following the convolutional feature extraction, the output is reshaped into a sequence structure and fed into an LSTM layer that examines the temporal dependencies of the extracted features. For an input feature sequence $x_t$ at time step t, the LSTM layer updates its cell state $c_t$ and hidden state $h_t$ using the following equations:

$$\begin{array}{cc}\hfill f_t& =\sigma (W_f·h_{t-1}+U_f·x_t+b_f)\hfill \end{array}$$

(27)

$$\begin{array}{cc}\hfill i_t& =\sigma (W_i·h_{t-1}+U_i·x_t+b_i)\hfill \end{array}$$

(28)

$$\begin{array}{cc}\hfill {\tilde{c}}_t& =tanh(W_c·h_{t-1}+U_c·x_t+b_c)\hfill \end{array}$$

(29)

$$\begin{array}{cc}\hfill c_t& =f_t·c_{t-1}+i_t·{\tilde{c}}_t\hfill \end{array}$$

(30)

$$\begin{array}{cc}\hfill h_t& =o_t·tanh\left(c_t\right)\hfill \end{array}$$

(31)

where $f_t$, $i_t$, and $o_t$ are the forget, input, and output gates respectively; W and U are weight matrices, and b is the bias vector. This transformation sequence allows the LSTM to learn long-term dependencies present in the input data [20].

The final output from the LSTM layer, $h_t$, represents the processed temporal features and is passed to a fully connected layer with softmax activation for classification. The softmax function (class probability prediction) is expressed as:

$${\widehat{y}}_i={\displaystyle \frac{e^{z_i}}{{\sum }_{j=1}^C{e}^{z_j}}},$$

(32)

where ${\widehat{y}}_i$ is the probability of class i, $z_i$ is the logit for class i, and C is the total number of classes.

CRNNs are optimized for speech processing tasks (e.g., automatic speech recognition and speaker identification) by successfully capturing spatial and temporal dependencies in the audio data [13,18]. Convolutional layers learn local time-frequency representations, while LSTM layers preserve sequential dependencies, making CRNNs effective for challenging audio and sequential data representations.

3. Applications

3.1. Speech Recognition

Speech recognition is the task of translating spoken language into text or machine understandable commands. It is another fundamental one in the area of speech signal processing, and has been extensively used in virtual assistant, transcription, and voice-activated systems, etc. The state-of-the-art performance of speech recognition systems is significantly enhanced by convolutional-based system architectures through effectively capturing local and global aspects of the speech signal.

Figure 5. Speech Signal Processing Pipeline.

Figure 5. Speech Signal Processing Pipeline.

The overall objective in speech recognition is to represent the probability of a word sequence $W=\{w_1,w_2,\cdots ,w_T\}$ conditioned on a set of acoustic features $X=\{x_1,x_2,\cdots ,x_T\}$. This is often formulated using Bayesian decision theory:

$$P\left(W\right|X)={\displaystyle \frac{P\left(X\right|W\left)P\right(W)}{P\left(X\right)}}$$

(33)

And where $P\left(X\right|W)$, $P\left(W\right)$, and $P\left(X\right)$ are the acoustic and language models and evidence with the possibility to be set to zero during decoding.

Convolutional Neural Networks (CNNs) have been used before to model $P\left(X\right|W)$ learning hierarchical representations of input features [19]. Convolutional neural networks (CNNs) extract local temporal and spectral correlations in speech signals by means of convolutional filters. For speech recognition Convolutional Neural Networks (CNNs), the convolution process is represented as:

$$y_{i,j}=\sigma \left(\sum _{m=-M}^M\sum _{n=-N}^N{w}_{m,n}·x_{i+m,j+n}+b\right)$$

(34)

where $y_{i,j}$ is the output feature map, $x_{i,j}$ is the input feature map, $w_{m,n}$ are the weights of the convolutional kernel, b is the bias term, and $\sigma$ is the activation function.

Conformers, introduced by Gulati et al. [1] refine CNNs by incorporating self-attention mechanisms that can learn long-range information without the loss of the ability to model local features in the convolution. The Conformer block embeds convolutional blocks and Transformer layers, and the output can be expressed as:

$$\begin{array}{cc}\hfill \mathrm{ConformerBlock}\left(X\right)=& {\mathrm{F}}_{{\displaystyle \frac{1}{2}}}\left(X\right)+\mathrm{M}\left(X\right)+\hfill \\ \hfill & \mathrm{C}\left(X\right)+{\mathrm{F}}_{{\displaystyle \frac{1}{2}}}\left(X\right)\hfill \end{array}$$

(35)

where ${\mathrm{F}}_{\mathrm{half}}$ is a feed-forward network with half the step size, M is multi-head self-attention, and C represents the convolution module.

The depthwise separable convolutions unit in the architecture of the Conformer learns relationships between neighbors:

$$Y=X+\mathrm{PointwiseConv}\left(\mathrm{GLU}\right(\mathrm{DepthwiseConv}\left(X\right)\left)\right)$$

(36)

Where the convolution filter is different for each input channel in DepthwiseConv, the gated linear unit activation GLU, and combined channels in PointwiseConv.

Convolutional Recurrent Neural Networks (CRNNs) are a mixture of CNNs and recurrent units (e.g., Long Short-Term Memory (LSTM) networks) to extract spatial and temporal features in speech signals (see [11]). Local features are extracted by the convolutional neural network layers and long-term temporal context is learned by the recurrent layers. The CRNN output can be described as:

$$H_t=\mathrm{LSTM}(\mathrm{CNN}\left(X_t\right),H_{t-1})$$

(37)

Where $X_t$ is the input at time t, $H_t$ is the hidden state, and $\mathrm{CNN}\left(X_t\right)$ outputs the feature representation of input.

Residual Networks (ResNets) allow the training of extremely deep CNNs by adding residual connections to overcome the vanishing gradient problem [7]. The residual connection is derived by summing over the input of a layer to the output of a layer:

$$Y=F(X,W)+X$$

(38)

Where $F(X,W)$ is the output of the convolutional layers, with weight W, and X is the input to the residual block.

In the area of statistical signal processing, these architectures help to estimate the acoustic model $P\left(X\right|W)$ more accurately by means of robust feature extraction and modeling. They enhance the discriminative capability of speech recognition systems (e.g., in the presence of noise or limited training data) [5,19].

For example, Alami et al. [19] showed that by learning invariant features in spectrograms, CNNs can perform noise-robust speech recognition. Gulati et al. [1] demonstrated that Conformers outperformed conventional CNNs and Transformers by leveraging both convolution and self-attention capabilities.

In addition, the combination of statistical approaches and deep learning architectures has resulted in hybrid models that continue to enhance performance. For example, hybrid Hidden Markov Model (HMM)-DNN architectures employ convolutional structures to approximate emission probabilities of HMMs [20].

3.2. Speaker Identification

Speaker identification is the process of identifying the identity of a speaker from vocal characteristics. In applications ranging from security systems, personalized user interfaces, and forensic investigation, this task is extremely crucial. Convolution-based architectures have been instrumental in enhancing the accuracies and robustness of speech-recognition systems by capturing the unique variability in each person’s voice.

Figure 6. Speaker Identification Pipeline.

Figure 6. Speaker Identification Pipeline.

The main task in speaker identification is to estimate the probability $P\left(S\right|X)$ that a certain speaker S is spoken for a set of acoustic feature sequences $X=\{x_1,x_2,\cdots ,x_t\}$. This can be formulated using Bayesian inference as:

$$P\left(S\right|X)={\displaystyle \frac{P\left(X\right|S\left)P\right(S)}{P\left(X\right)}}$$

(39)

Here, $P\left(X\right|S)$, $P\left(S\right)$, and $P\left(X\right)$ are the acoustic model, prior probability of the speaker, and evidence, respectively.

Convolutional Neural Networks (CNNs) have been applied with success to model $P\left(X\right|S)$ through learning hierarchical features of the input acoustic representations, such as Mel-Frequency Cepstral Coefficients (MFCCs) [15]. The convolutional operation of CNNs for use in speaker identification can be written as:

$$Y_{i,j}=\sigma \left(\sum _{m=-M}^M\sum _{n=-N}^N{w}_{m,n}·x_{i+m,j+n}+b\right)$$

(40)

Where $Y_{i,j}$ is the output feature map $x_{i,j}$ is the input feature map, $w_{m,n}$ is the convolutional kernel weights, b is the bias, and $\sigma$ is the activation function.

Convolutional Recurrent Neural Networks (CRNNs) approximate spatial and temporal relationships in speech signals by combining convolutional neural networks (CNNs) and recurrent networks (e.g., Long Short-Term Memory (LSTM) networks) [11]. The architecture of the CRNN model analyzes input sequence $X_t$ at time t as:

$$H_t=\mathrm{LSTM}(\mathrm{CNN}\left(X_t\right),H_{t-1})$$

(41)

Specifically, in which $H_t$ (hidden state) and $\mathrm{CNN}\left(X_t\right)$ (extracting spatial information using the convolutional neural network) are applied.

Residual networks (ResNets) train deep CNNs by adding "residual connections" that solve the vanishing gradient problem and enable training of models with increased depth without performance loss [20]. The residual connection is mathematically represented as:

$$Y=F(X,W)+X$$

(42)

Where $F(X,W)$ is the output of convolutional layers with weights W, where X is the input of residual block.

Gaussian Mixture Models (GMMs) are frequently employed together with CNNs for estimating the distribution of acoustic features of each speaker [17]. The probability $P\left(X\right|S)$ can be expressed as:

$$P\left(X\right|S)=\sum _{k=1}^K{\omega }_k\mathcal{N}\left(X\right|{\mu }_k,{\Sigma }_k)$$

(43)

Here, ${\omega }_k$ are the mixing weights, and $\mathcal{N}\left(X\right|{\mu }_k,{\Sigma }_k)$ are the components of the Gaussian distributions with mean ${\mu }_k$ and covariance ${\Sigma }_k$.

In noisy conditions, convolutional-based models augmented with statistical signal processing (SSP) techniques have been demonstrated to be highly robust. For instance, Na et al. As demonstrated in [15], CNNs with noise-resistant feature extraction techniques dramatically improve the effectiveness of speaker recognition in the presence of acoustic background noise. In addition, by combining GMM and CNN, hybrid models have enabled real-time speaker recognition at good accuracy [17].

Generally, convolution-based architectures are naturally suited to statistical signal processing paradigms for the ability to learn robust features as well as model subject speaker properties.

3.3. Emotion Detection

Speech emotion recognition is the task by which the emotional state of a person is decoded from vocalization. The role of the task is significant for applications such as human-computer interaction, mental health monitoring and automatic customer service. Conv-based architectures have now allowed impressive performance gains for emotion detection systems regarding both accuracy and robustness, since they are capable of modeling the patterns and variability of speech signals underlying a wide range of emotions.

The objective in emotion detection is to model the probability $P\left(E\right|X)$ of an emotion E given an acoustic feature sequence $X=\{x_1,x_2,\cdots ,x_T\}$. This can be formulated using Bayesian inference as:

$$P\left(E\right|X)={\displaystyle \frac{P\left(X\right|E\left)P\right(E)}{P\left(X\right)}}$$

(44)

Where $P\left(X\right|E)$ denotes the emotional acoustic model, $P\left(E\right)$ the prior probability of the emotion and $P\left(X\right)$ the evidence.

Convolutional Neural Networks (CNNs) have been widely utilized to encode $P\left(X\right|E)$ learning hierarchical features from input acoustic representations such as Mel-Frequency Cepstral Coefficients (MFCCs) [13]. The convolution function in CNNs (for emotion detection) can be represented as:

$$y_{i,j}=\sigma \left(\sum _{m=-M}^M\sum _{n=-N}^N{w}_{m,n}·x_{i+m,j+n}+b\right)$$

(45)

Where $y_{i,j}$ is the output feature map, $x_{i,j}$ is the input feature map, $w_{m,n}$ are the weights of convolutional kernels, b is the bias, and $\sigma$ is the activation function.

CNN-LSTM networks use convolution units with Long Short Term Memory (LSTM) units for joint acquisition of spatial and temporal features in speech signals [16]. The hybrid architecture views the input sequence $X_t$ at time t as:

$$H_t=\mathrm{LSTM}(\mathrm{CNN}\left(X_t\right),H_{t-1})$$

(46)

where $H_t$ is the hidden state at time t, and the spatial features are obtained from the input with $\mathrm{CNN}\left(X_t\right)$.

Residual networks (ResNets) enhance the performances of deep Convolutional Neural Networks (CNNs) just by inserting residual connections, enabling deep network training without performance degrading [7]. Residual connection of emotion detection can be described as:

$$Y=F(X,W)+X$$

(47)

In which $F(X,W)$ is the output obtained from convolutional layers with weights W and X is the input provided to the residual block.

Activation functions and normalization techniques in emotion detection based deep learning models are commonly applied to ensure training stability and convergence. E.g., information flow on the network is restricted using the Gated Linear Unit (GLU) activation function:

$$\mathrm{GLU}(a,b)=a\otimes \sigma \left(b\right)$$

(48)

In which a and b are input tensors, ⊗ denotes element-wise multiplication, and $\sigma$ is the sigmoid function.

In the area of statistical signal processing, such convolution-based architectures enhance the process of feature extraction through considering the distribution of so-called emotional features in the speech signal. Wang et al. [18] survey various deep learning approaches for emotion recognition, highlighting the effectiveness of CNNs in capturing discriminative features. Prabhu and Raj¹ demonstrated that CNNs can be applied to discriminative fine emotional cues by the learning of abstract features from the convolution of the spectrogram.

Furthermore, CNN-LSTM networks as proposed by Kumar and Sharma [16] incorporate temporal dynamics of speech for an improvement of the emotion classification performance. These hybrid models combine the local feature extraction capabilities of CNNs with the sequence modeling strengths of LSTMs, providing a comprehensive framework for emotion detection.

Conceptually, convolution-based architectures are consistent with principles of statistical signal processing by providing discriminative feature learning and good models of emotionality for speech signals. These developments have resulted in more precise and trustworthy emotion detection systems capable of performing robustly in heterogeneous and dynamic environments.

4. Comparative Analysis of the Architectures

Model size, accuracy, speed, and training cost may all be used to compare the four models. The findings from the VoxForge and Voxlingua6 datasets [9] served as the basis for the related analysis. VoxForge includes speech data in English, German, Russian, Italian, Spanish, and French, whereas Voxlingua6 adds more speaker and language variability. Both datasets include speech data from various languages. Data statistics for each dataset are shown in Table 1.

Table 1. Data Statistics on VoxForge and Voxlingua6 Datasets.

Characteristic	Train	Validation	Test
English	291 spk	27 spk	41 spk
German	90 spk	7 spk	7 spk
Russian	193 spk	7 spk	8 spk
Italian	152 spk	16 spk	15 spk
Spanish	280 spk	10 spk	18 spk
French	195 spk	8 spk	9 spk

Table 1. Data Statistics on VoxForge and Voxlingua6 Datasets.

Characteristic	Train	Validation	Test
English	291 spk	27 spk	41 spk
German	90 spk	7 spk	7 spk
Russian	193 spk	7 spk	8 spk
Italian	152 spk	16 spk	15 spk
Spanish	280 spk	10 spk	18 spk
French	195 spk	8 spk	9 spk

4.1. Training Cost

The amount of processing power required to train each model is known as the training cost. Models with more parameters often demand more time and processing power. The CNN architecture is light (6 million parameters) and hence versatile, whereas the Conformer architecture is heavy (15.5 million parameters), as seen in Table 2 from [9]. Convolutional and recurrent layers are combined in CRNN, which contains over 19.5 million parameters. Because of the intricate convolutional self-attention mechanism, the Conformer and CRNN require additional processing resources, particularly in noisy and multilingual environments like Voxlingua6. The memory space and computational cost during deployment are directly impacted by the model size, or the number of parameters.

Table 2. Total Number of Parameters in Each Model.

Model	# of Parameters (million)
CNN	6.0
CRNN	19.5
Residual Network	23.5
Conformer	15.5

Table 2. Total Number of Parameters in Each Model.

Model	# of Parameters (million)
CNN	6.0
CRNN	19.5
Residual Network	23.5
Conformer	15.5

Figure 7. Model Parameter Sizes

Figure 7. Model Parameter Sizes

4.2. Accuracy

The Conformer on average outperforms the other architectures (error rate 5.27% on the Voxlingua6 Dev set). CNNs follow closely with an error rate of 7.18%, while the CRNN and Residual Network perform slightly worse, reflecting the trade-off between model complexity and accuracy.

Table 3. Error Rates [%] of Models on Voxlingua6 Dev Set

Model	Error Rate [%]
CNN	7.18
CRNN	11.35
Residual Network	8.56
Conformer	5.27

Table 3. Error Rates [%] of Models on Voxlingua6 Dev Set

Model	Error Rate [%]
CNN	7.18
CRNN	11.35
Residual Network	8.56
Conformer	5.27

Figure 8. Error Rates Comparison

Figure 8. Error Rates Comparison

4.3. Speed

In terms of speed, the CNN is most efficient for real-time applications, while the Conformer strikes a balance between speed and accuracy, making it suitable for slightly delayed yet accurate systems.

5. Conclusion

In order to accomplish speech signal processing tasks including speaker identification, emotion detection, and voice recognition, this article compared CNN, Conformer, CRNN, and Residual Network designs. We tested these models on training cost, model size, accuracy, and inference speed using the VoxForge and Voxlingua6 datasets. We discovered that Conformers are more accurate than CNNs, which are more suited for low-resource situations because of their lower size [1,9].

Future studies will concentrate on improving noise resistance, developing effective, low-latency models for real-time applications, and reducing architectural complexity to make them easier to utilise on devices with constrained resources. Investigating hybrid configurations that combine convolution and self-supervised learning [4] may result in additional advancements by striking a balance between model complexity and performance.