\section{Introduction}
{\let\thefootnote\relax\footnotetext{This work was supported by Korea Environment Industry \& Technology Institute(KEITI) through Exotic Invasive Species Management Program, funded by Korea Ministry of Environment(MOE) (2021002280004). Corresponding Author:Hanseok Ko.
}}


In audio-based deep learning applications, noise disturbance would occur performance degradation since the noise signal may shift the domain of target signals. In particular, unseen noise is difficult to anticipate and various methods have been developed to mitigate its effects. Through adversarial loss \cite{pascual2017segan,fu2019metricgan} and speech quality metric learning \cite{hu2007evaluation,fu2019learning,xu2021deep}, a generative model enhances the speech signal against noise. A classification-driven approach \cite{shon2019voiceid,kim2020dual} would mitigate noisy signals through an end-to-end fashion. Assuming that noise signals are cumbersome features for the classification task, a T-F mask is estimated by an input T-F feature and it is recursively multiplied with the input T-F feature to mitigate the noise effect. Although these methods perform reasonably well in various applications, their implementations are computationally expensive. In our previous work, we proposed a lightweight dynamic filter \cite{kim2021lightweight} as an alternative to robust and low resource keyword spotting. The filter was divided into two subtypes: Pixel Dynamic Filter (PDF) and Instance-Level Dynamic Filter (IDF). For PDF, a single channel convolution layer strides T-F features and the output of the convolution is considered pixel-level scalar weights. In IDF, weight vectors are extracted by using global averaging pooling and Fully Connected (FC) layers. These learning methods reduce model complexity and improve Keyword Spotting (KWS) performance in various noisy environments.

Although the feature averaging process would relieve the computational cost, a simple feature averaging (e.g. feature mean) might be difficult for capturing task salient features and it would degrade the performance of dynamic weights. It would be particularly weak in noisy environments that are unseen. In this paper, Chunk Separated Convolution (CS-Conv) and Dynamic Attention Pooling (DAP) are proposed as effective dynamic filters that are robust against unseen signals. Based on the Dual-Path RNN framework \cite{luo2020dual}, the T-F features are split into non-overlapped chunk features, and separable convolutions are performed on intra chunks and inter chunks, respectively. Additionally, our proposed DAP maps the output feature of CS-Conv to a temporal saliency-based embedding vector. A convolution layer in DAP produces vector weights that are used to compute attention scores depending on temporal frames. This process enables the dynamic filter to focus on temporally salient features to obtain the embedding vector.
We confirm that our proposed dynamic filter utilizes 250K Flops and 1.5K of parameters for its implementation.
The proposed method is applied to IDF of our previous work and experiments are carried out on Speaker Verification (SV) and KWS tasks. For KWS and SV evaluations, we use Speech command data \cite{warden2018speech} and voxceleb data \cite{nagrani2020voxceleb,chung2018voxceleb2}. We confirm that our proposed method enhances the performance of KWS and SV in unseen environments (unseen noise and unseen speakers) over our previous work with similar computation costs.
\section{Related Works}
Dynamic Filter Network \cite{jia2016dynamic} (DFN) is a filter adaptation method depending on input data. Instead of optimizing the initialized weight vector, the output features of the neural networks (filter generator) are used as the weight vectors of the main task model. In this learning process, the weights would not be fixed since they are generated by the filter generator and it has been shown reasonable performance in various deep learning applications \cite{wu2019pay,kim2020dual,fujita2020attention}. However, the implementation of DFN requires a high computational cost (time and space complexity) since its filter generation process. To alleviate this issue, small footprint dynamic models have been proposed. Decoupled dynamic filter \cite{zhou2021decoupled} splits the filter generation network as two branches (channel and spatial parts) by using Global Average Pooling (GAP). These two filters produce channel and spatial related weights respectively, and they are combined to compute the convolution process. In our earlier work, we proposed a front-end light dynamic filter for KWS. We divided the filter generator network into PDF and IDF. In the PDF, the weights of each pixel are produced by a single layer of CNN. In the IDF, kernel weights for each utterance are generated by GAP and Fully Connected (FC) layers. Then, the weights are combined to drive single-channel CNN and it shows robust KWS results against unseen noise environments. Although these learning frameworks reduce the computational cost of the DFN, their performance would be limited as they explore the simple mean of the functions. In this work, we aim to develop an efficient dynamic filter, where filter generators small footprint dynamic filter which works efficiently over simple feature average.
\section{Efficient dynamic filter}
\subsection{Chunk Separable Convolution}
Our proposed CS-Conv is motivated by the Dual-Path Recurrent Neural Network (DP-RNN) \cite{luo2020dual}. In DP-RNN, temporally overlapping T-F chunks are fed to two ways of RNNs (inter and intra chunk) and the output features are assembled by overlap adding. Instead of the RNN model, we utilized separable CNN by reducing the temporal size and it is computationally more efficient than RNN. To this end, We divide T-F features into several chunks that do not overlap in time and separable convolutions are applied to intra chunk and inter chunk respectively. We change the format of the input T-F feature ($x \in \mathbb{R}^{[F,T]}$, where $F$ and $T$ denote frequency and temporal dimension respectively) as non-overlapping chunks ($x_c \in \mathbb{R}^{[F,C,T/C]}$, where $c$ denotes chunk size). Then, separable convolutions are applied to intra and inter-chunk directions. In the intra chunk direction, $w_{itra}\in \mathbb{R}^{[K,K,T/C]}$, where $k$ denotes kernel size, strides each chunk feature and the outputs are fed to the inter chunk convolution layer which has $w_{iter}\in \mathbb{R}^{[K,K,C]}$ of CNN kernel. The CS-Conv procedure is as follows: 
\begin{equation}
   CSconv(x_c)= \sigma(conv(\sigma(conv(x_c,w_{itra})),w_{iter})),
  \label{eq2}
\end{equation}
where $\sigma (\cdot)$ and $conv (\cdot)$ denote the feature normalization and the implementation of CNN, respectively. In each convolution layer, the kernels are put in stride to reduce the temporal dimension and feature normalization is applied to the output of CNN. The intra and inter chunk convolution extracts the local patches and the large interval features respectively. From this process, T-F features are mapped to long-term and short-term features, which retain the original frequency dimension while the temporal dimension is reduced. 
\subsection{Dynamic Attention Pooling}
In the deep learning framework, the GAP is simply applied to obtain a low-dimensional feature embedding. Based on this, a Statistic Averaging Pooling (SAP)  \cite{snyder2018x}, and a Temporal Attention Pooling (TAP) \cite{safari2019self} have developed. In particular, TAP adjusts temporal saliency by using the dot product between T-F features and learning variables. However, as TAP utilizes static weights, its performance might be limited. In our proposed DAP, DFN is employed to produce weights to compute attention scores. The process of DAP is as follows: 
\begin{equation}
      w_d=conv(x), 
  \label{eq2}
\end{equation}
\begin{equation}
   DAP(x,w_d)= \sum{\rho(x \times w_d) \times x}, 
  \label{eq2}
\end{equation}
where $\rho(\cdot)$ denotes softmax normalization. A single layer of 1D convolution layer, where the kernel strides temporal axis, is employed to generate dynamic weight ($w_d \in \mathbb{R}^{[F]}$), and it is used to compute attention scores according to the time step by using dot product between the input feature and $w_d$. Then, softmax normalization maps the score to [0,1]. The normalized scores are multiplied with the input feature and the feature embedding is obtained by conducting temporal mean.
\subsection{Network Architecture}
\begin{figure}[]
     \centering
     \includegraphics[scale=0.20]{FIGURE1.pdf}
     \caption{The pipeline of our proposed method: PDF, IDF, and CS-Conv denote Pixel Dynamic Filter, Instance-level Dynamic Filter, and Chunk Separable Convolution, respectively. $k$ and $N$ denote the size of kernel and pixel, respectively. The IDF produces $1 \times K$ weight and the PDF process produces $N \times 1$ weight. These weights are multiplied and the convolution is computed by using the generated weights}
    \label{fig:three graphs}
\end{figure}
As shown in Figure 1, we modify the IDF part from our previous work. Instead of simple pooling and FC layers, the CS-Conv block is utilized to compute long-term and short-term features, and then DAP is applied to map low-dimensional embedding. Then, an FC layer and Swish activation \cite{ramachandran2017searching} are used to generate a weight vector. Our dynamic filter and main task model are optimized by classification loss (cross-entropy loss). For feature normalization, we use the Instance Normalization (IN) \cite{ulyanov2016instance} framework, where the mean standard deviation normalization and learnable affine transform are applied to the frequency axis. With CS-Conv, we apply feature normalization to each chunk individually. In the other normalization layers, we divide the input features into two temporal chunks and apply feature normalization to each chunk respectively.
\subsection{Implementation detail}
In CS-Conv, we use $2 \times 2$ of CNN kernels with a dilation size of 2 and stride size of (1,2) both two convolution layers. In DAP, $1 \times 25$ CNN kernel with stride size of (1,10) is utilized to generate the dynamic weights, which is a 40-dimensional vector. The output of DAP is fed to $40 \times 9$ to produce the IDF weighs. In PDF, $3 \times 3$ kernel with a dilation size of 2 is used to produce the PDF weights. 
\section{Keyword Spotting}
\subsection{Experimental setup}
{\bf Dateset.} We used speech command datasets v1 and v2 \cite{warden2018speech} for evaluating KWS performance. We utilized 10 keywords with two extra classes (unknown or silent) for model training and we injected background noise and added random time-shifting. For evaluating robustness against noise, We utilized DCASE \cite{mesaros2019acoustic}, Urbansound8K \cite{salamon2014dataset} and WHAM \cite{Wichern2019WHAM} datasets. we randomly selected an audio sample from the noise data and mixed it with the test data with 5 SNRs [20dB, 15dB, 10dB, 5dB, and 0dB].\\
{\bf Implementation detail.} 40 coefficient of Mel Frequency Cepstral Coefficients constructed with 30ms of windows, 10ms overlap, and 64 melfilters. This process gives a (40,98) size of audio features. In the training process, we used a batch size of 100, 30k iterations, and an ADAM optimizer with a 0.001 initial learning rate. Every 10K iteration, the learning rate is reduced by 0.1 rates. In the PDF and the dynamic convolution process, we used $3\times3$ CNN kernel ($k=9$) dilated by 2 with stride=1. In the IDF, $2\times2$ kernel dilated by 2 with stride=(1,2) is utilized to each CSconv and FC layer follows $40 \times k$ dimension. We refrain Spec-Augmentation \cite{park2019specaugment} for the fair comparison. 
\subsection{Baselines}
Four different baseline architectures were used for comparisons. We apply our method to the front-end of the TENet12 architecture \cite{li2020small} and compared the KWS result with the following baselines.\\
{\bf TCNet.} TCNet \cite{choi2019temporal} (or TC-Resnet) utilizes temporal convolution for low computational cost model. TCNet8 contains 3 convolution blocks and 1 FC layer. Each convolution block has two layers of temporal convolution with a skip-connection. Similarly, TCNet14 contains 6 convolution blocks and 1 FC layer. \\
{\bf TENet.} TENet \cite{li2020small} utilizes depth-separable temporal convolution. A convolution block contains two 1D convolution layers and a single separable convolution layer. TENet6 and TENet12 have 6 and 12 convolution blocks respectively. TENet has 32 output channels for each convolution block and TENet-n has 16 output channels for each convolution block.\\
{\bf MHA-RNN.} MHA-RNN\cite{rybakov2020streaming} utilizes CRNN and self-attention models to compute the keyword embedding vector. Two layers of FC produce KWS probabilities, and spec augmentation \cite{park2019specaugment} is used to train the model.\\ 
{\bf Neural Architecture Search.} Neural Architecture Search (NAS) is a network designing method by minimizing search costs (Flops, memory, accuracy, etc.). We compare our method with several NAS methods including Differentiable Architecture Search (DARTS). Please see details of the model in \cite{mo2020neural,zhang2021autokws}.\\
{\bf Lightweight convolution.} Lightweight Convolution \cite{wu2019pay} (LConv.) block is designed to perform low computation separable convolution through weight sharing and weight normalization. It contains two layers of linear, a Gated Linear Unit (GLU), and the separable convolution. We use the single LConv block in the front-end of the TENet12 model. In the first linear layer, the frequency dimension of the T-F features is increased by 80 and the GLU activation is applied. Then, the separable convolution with $H=10$ and the other linear layer are performed by preserving the feature dimension. Additionally, instead of employing static weights in the separable convolution, we utilize a single linear layer to produce the weight of the convolution (Dyconv).\\
{\bf LDy-TENet.} We previously developed LDy-TENet \cite{kim2021lightweight} which applied a lightweight dynamic filter to the front-end of the TENET models. In the PDF process, $3\times3$ kernel with a dilation size of 2 is used. In IDF process $40 \times 40$ and $40 \times k$ dimension of weights are used.
 \subsection{Result discussion}
\begin{table}[h]
\scriptsize
  \label{tab:word_styles}
  \begin{tabular}{cccccc}
    \toprule
    \multicolumn{1}{c}{\multirow{2}{*}{\textbf{Model}}}&\multicolumn{1}{c}{\multirow{2}{*}{\textbf{(Par.,Flops.)}}}&\multicolumn{2}{c}{V1}&\multicolumn{2}{c}{V2}\\\cline{3-6}
    \multicolumn{1}{c}{}&\multicolumn{1}{c}{}&\textbf{Acc}& \textbf{Best}& \textbf{Acc}& \textbf{Best}\\
    \midrule
    TCNet8\cite{choi2019temporal}& (145K,4.40M)& - &96.2&- &- \\
    TCNet14\cite{choi2019temporal}& (305K,8.26M)& - &96.6&96.53&96.8 \\
    \midrule
    TENet6-n\cite{li2020small}& (17K,1.26M)& - &96.0& 96.30&96.5 \\
    TENet12-n\cite{li2020small}& (31K,1.97M)& - &96.3& 96.55&96.9 \\
    TENet6\cite{li2020small}& (54K,3.95M)& - &96.4& 96.83&97.0 \\
    TENet12\cite{li2020small}& (100K,6.42M)& - &96.6 &97.10&97.3\\
    \midrule
    MHA-RNN$^{\dagger}$\cite{rybakov2020streaming}& (743K,87.2M)& - &97.2& -&98.0 \\
    \midrule
    NAS2\cite{mo2020neural}& (886K,-)& - &97.2& -& -\\
    Random\cite{zhang2021autokws}& (196K,8.8M)& 96.58 &96.8& -&- \\
    DARTS\cite{zhang2021autokws}& (93K,4.9M)& 96.63 &96.9& 96.92&97.1 \\
    F-DARTS\cite{zhang2021autokws}& (188K,10.6M)& 96.70 &96.9&97.11& 97.4\\
    N-DARTS\cite{zhang2021autokws}& (109K,6.3M)& 96.79 &97.2& 97.18&97.4 \\
    \midrule
    LightConv\cite{wu2019pay}&(105K,7.40M)&96.88&97.0& 97.24&97.3\\
    DyConv\cite{wu2019pay}&(107K,7.69M)&96.89&97.1& 96.26&97.4\\
    \midrule
    LDy-TENet6-n& (19K,1.48M)& 96.48&97.0 & 96.10&96.8\\
    LDy-TENet12-n& (33K,2.19M)& 96.69&96.9& 96.80&97.2 \\
    LDy-TENet6& (56K,4.17M)& 96.77&96.9 & 97.26&97.4\\
    LDy-TENet12& (102K,6.64M)& 96.95 &97.1 & 97.35&97.6\\
    \midrule
    EDy-TENet12& (102K,6.68M)& \textbf{97.07} &\textbf{97.4}& \textbf{97.42}&\textbf{97.8} \\
    \bottomrule
  \end{tabular}
    \caption{Comparison with lightweight models on Speech Command v1 and v2: Notation of $\dagger$ denotes the application of Spec-Augmentation \cite{park2019specaugment}. For an accurate experiment, 8 times averaging accuracy and the best performance are presented.}
\end{table}
\begin{table}[h]
  \label{tab:word_styles}
  \centering
  \begin{tabular}{cccc}
    \toprule
    \textbf{Acc}& \textbf{GAP}& \textbf{TAP}&\textbf{DAP}\\
    \midrule
    \textbf{V1}& 97.02&97.04&\textbf{97.07}\\
    \textbf{V2}& 97.22&97.35&\textbf{97.42}\\
    \bottomrule
  \end{tabular}
  \caption{Comparison of feature pooling methods depending on the Speech Commands datasets v1 and v2.}
\end{table}

\begin{table*}[t]
  \label{tab:word_styles}
  \centering
  \footnotesize
\begin{tabular}{c|c|cccccccccccc}
\toprule
\multicolumn{1}{c|}{\multirow{3}{*}{\textbf{Noise}}} & \multicolumn{1}{c|}{\multirow{3}{*}{\begin{tabular}[c]{@{}c@{}}SNR\\ (dB)\end{tabular}}} & \multicolumn{12}{c}{\textbf{Model}}\\ \cline{3-14}
\multicolumn{1}{c|}{}&\multicolumn{1}{c|}{}&\multicolumn{2}{c}{\textbf{Ours}}&\multicolumn{2}{c}{\textbf{LDy}}&\multicolumn{2}{c}{\textbf{Dconv}}&\multicolumn{2}{c}{\textbf{Lconv}}& \multicolumn{2}{c}{\textbf{TENet}}& \multicolumn{2}{c}{\textbf{TCNet}}\\\cline{3-14}
\multicolumn{1}{c|}{}&\multicolumn{1}{c|}{}&\textbf{v1}&\textbf{v2}&\textbf{v1}&\textbf{v2}&\textbf{v1}& \textbf{v2}&\textbf{v1}&\textbf{v2}&\textbf{v1}&\textbf{v2}&\textbf{v1}&\textbf{v2}\\
\hline
\multirow{5}{*}{{\begin{tabular}[c]{@{}c@{}}\textbf{DCASE}\\\cite{mesaros2019acoustic}\end{tabular}}}                                                                                 &\textbf{20} &\textbf{96.72}& \textbf{97.04}& 96.58& 96.95&96.55& 96.74&96.62& 96.81&96.28& 96.59&95.85&96.09\\
						         &\textbf{15} &\textbf{96.5}& \textbf{96.45}&96.44& 96.31&96.35& 96.08&96.37& 96.08&96.23& 96.01&95.59&95.39\\
					            &\textbf{10} & \textbf{95.32}& \textbf{95.64}&95.10& 95.56&95.01& 95.09&95.05& 95.17&94.94& 95.15&94.25&94.33\\
                                &\textbf{5} & \textbf{93.54}&\textbf{93.42} &93.00& 93.35&92.27& 92.42&92.80& 92.80&92.87& 92.53&91.79&91.74\\
					            &\textbf{0} & \textbf{89.36}& \textbf{88.73}&88.41& 88.46&87.51& 86.64&87.67& 87.01&88.14& 86.65&86.01&85.96\\\midrule
\multirow{5}{*}{\begin{tabular}[c]{@{}c@{}}\textbf{Urban}\\\cite{salamon2014dataset}\end{tabular}}                                                                                    &\textbf{20} & \textbf{96.08}& \textbf{96.35}&95.94& 96.33&95.81& 95.81&95.84& 96.06&95.72& 95.92&95.16&95.08\\
						         &\textbf{15} & \textbf{95.2}& \textbf{94.95}&95.09& 94.91&94.69& 94.69&94.49& 94.45&94.69& 94.31&93.61&93.53\\
					            &\textbf{10} & \textbf{93.10}& \textbf{93.04}&92.82& 92.79&92.03& 92.03&92.25& 91.97&92.17&92.07 &90.77&90.81\\
                            &\textbf{5} & \textbf{89.63}& 87.51&89.19& \textbf{87.56}&87.80& 87.08&87.60& 85.87&87.97&86.18 &86.38&84.53\\
					            &\textbf{0} & \textbf{80.50}& \textbf{79.63}&78.55& 79.38&76.20& 75.86&76.26& 76.15&77.54& 76.44&74.20&74.34\\\midrule
\multirow{5}{*}{\begin{tabular}[c]{@{}c@{}}\textbf{WHAM}\\\cite{Wichern2019WHAM}\end{tabular}}                                                                                        &\textbf{20} & \textbf{96.17}& \textbf{96.30}&96.09& 96.27&95.96& 96.08&96.02& 96.13&95.75& 95.99&95.43&95.35\\
						         &\textbf{15} & \textbf{95.50}& \textbf{95.40}&95.47& \textbf{95.40}&96.12& 94.61&95.23& 94.84&95.12& 94.74&94.44&93.45\\
					            &\textbf{10} & \textbf{93.06}& 93.39&92.91& \textbf{93.44}&92,39& 92.25&92.69& 92.71&92.67& 92.53&91.46&91.47\\
                                &\textbf{5} & \textbf{89.10}& \textbf{88.10}&88.19& 87.95&87.36& 86.26&87.83& 86.60&87.88& 86.37&85.72&85.42\\
					            &\textbf{0} & \textbf{77.79}& \textbf{76.97}&75.92& 76.37&74.52& 73.80&75.18& 74.30&75.19& 74.05&73.15&72.90\\\midrule
\multicolumn{2}{c|}{\textbf{Total-AVG.}} & \textbf{91.87}& \textbf{91.58}&91.31& 91.40&90.64& 90.25&90.79& 90.45&90.87& 90.37&89.59&89.36\\
\bottomrule
\end{tabular}
  \caption{Comparison with Unseen noise environment on the Speech Commands datasets v1 and v2: experiments are performed on EDy-TENet12 LDy-TENet12, TENet12, Lconv, Dconv, and TCNet14 model. SNR denotes signal-to-noise ratio.}
\end{table*}





Tables 1, 2, and 3 summarize the KWS results on the Speech Command dataset v1 and v2. The proposed method (EDy-TENet12) is applied to the IDF part of \cite{kim2021lightweight}. For a more thorough model evaluation, we repeated the experiment eight times.\\ 
{\bf Small footprint KWS.} Table 1 compares small footprint KWS performances with state-of-the-art methods. Par. and Flops. denote the number of training parameters and the computational cost, respectively. The results indicate that our proposed model takes 1.2\% of performance improvement over the LDy model with a small computation increase. In table 2, we compare our method with other feature pooling methods(GAP and TAP) to verify its effectiveness. The GAP, TAP, and DAP are compared based on EDy-TENet12. The TAP computes the temporal scores based on a 40-dimensional static weight vector. we confirm that the DAP shows an improvement over the TAP which utilizes static weights.\\ 
{\bf Unseen noisy environment.} Table 3 summarizes the KWS results on the unseen noisy environments. These results indicate that our proposed model is more robust than LDy and Dconv models which use a dynamic filter. Compared with LDy-TENet, our method takes 0.56\% (v1) and 0.18\% (v2) of improvement in performance on average. Even though performance improvements are not significant in the v2 dataset, v1 is considered to have reasonable performance over the LDy-TENet12 model in terms of computational cost. Particularly, 2\% performance improvement is shown in the v1 dataset of the Urban 0dB condition.\\
In summary, our method requires 1.5k of parameters with 257k of Flops. to implement whereas our previous work uses 2k parameters with 220k of Flops. to implement. Given the computational cost, we can conclude that our method efficiently enhances the performance of KWS over our previous work and the other dynamic filter approach with limited resources.
\section{Speaker Verification}
\subsection{Experimental setup}
{\bf Dateset.} The speaker model is trained on VoxCeleb2 data and it is evaluated by VoxCeleb1 data. we use 2 seconds of speech segments which are randomly chosen from each utterance and 40 dimensions of the log-mel spectrogram are extracted by a window of 25ms and step of 10ms. We perform mean and variance normalization by instance normalization fashion. Also, we do not apply any data augmentation and Voice Activation Detection (VAD) during the model training and evaluation.\\
{\bf Computational setup.} The baseline models we used are the TENet12 and LDy-TENet12 models. We modify the final convolution block of the TENet12 model as 128 channels and the vector format of the features is extracted by the TAP process. Then, we use two FC layers to match the output size to the number of speaker classes. A weights vector of $128 \times 512$ is used in the first FC layer and a weights vector of $512 \times 5994$ is used to extract the probabilities for speaker identification. We utilize the output of the first FC layer as speaker embedding for each utterance. In the LDy-TENet12, the lightweight dynamic filter is applied to the front-end of the modified TENet12 model.\\
{\bf Implementation detail.} In the training process, we use a batch size of 400, 500 epochs, and an ADAM optimizer with a 0.001 initial learning rate. In each epoch, 500 utterances of samples are randomly selected from each speaker and the learning rate is decreased by 0.999. The training takes approximately four days by using the PyTorch package with RTX-3090 GPU. For the speaker model training, we use Angular Prototypical loss \cite{chung2020defence} with an utterance of each mini-batch as 2. We select ten samples of 2-second audio segments per test utterance with fixed intervals and compute the cosine-based similarity between all combinations (100 pairs) in order to evaluate the trained network. The averaging similarity of all possible pairs is used as the similarity score. We utilize Equal Error Rate (EER) and Minimal Detection Cost Function (Min. DCF) as the evaluation metrics.\\
{\bf Evaluation protocol.} In this work, two different evaluation protocols (Voxceleb1-test and Voxceleb1-H) are used. Voxceleb1-test consists of 40 speaker identities which are equal to the original test set in Voxceleb1. Voxceleb1-H contains 1251 speaker identities and the sample pairs have the same nationality and gender. It is noted that the development set of VoxCeleb2 does not contain the same speaker identities in VoxCeleb1. This means that the evaluation is carried out in an open environment (unseen speaker).
\subsection{Result discussion}
Table 4 shows the SV results depending on the two different evaluation
protocols (Voxceleb1-test and Voxceleb1-H). We confirm that the dynamic filter in the front-end enhances the SV performance. Particularly, our proposed model takes 0.53\% of EER improvement in the Voxceleb1-H test set. As the weights of CNN are generated by the filter generator, it shows robust performance over unseen speakers. Particularly, our proposed method efficiently extract feature and it would enhance the performance of the dynamic filter better than our previous work.
\begin{table}[t]
  \label{tab:word_styles}
  \centering
  \begin{tabular}{c|cccccc}
    \toprule
    \multicolumn{1}{c|}{\multirow{2}{*}{\textbf{Model}}}&\multicolumn{2}{c}{Voxceleb-test}&\multicolumn{2}{c}{Voxceleb-H}\\\cline{2-5}
\multicolumn{1}{c|}{}&\textbf{EER}& \textbf{Min.DCF}&\textbf{EER}&\textbf{Min.DCF}\\
    \midrule
    \textbf{EDy}& \textbf{4.79}&\textbf{0.36}&\textbf{9.77}&\textbf{0.59}\\
    \textbf{LDy}& 4.97&0.38&10.30&0.62\\
    \textbf{TENet}& 5.30&0.38&10.43&0.63\\
    \bottomrule
  \end{tabular}
  \caption{Comparison of the speaker verification results.}
 
\end{table}
\section{Conclusion}
In this paper, we proposed an efficient dynamic filter to extract robust and low computational features. In our earlier work, we showed that a dynamic neural architecture in the front-end of the model would enhance the robustness against unseen noise. However, as the simple feature means was applied to reduce the computational cost, the performance of the dynamic filter is limited and it would particularly reduce performance in an unseen environment. To combat this limitation, we staged the separable convolutions by using temporal chunks (intra and inter-chunks) to extract a local feature and a global feature respectively. Then, a dynamic filter-based feature pooling was used to extract the low dimensional feature vector. This approach was applied to the Instance-level Dynamic Filter in our previous work and experiments were performed on the keyword spotting and speaker verification tasks. From the experimental results, it was shown that the proposed method enhances robustness against the unseen environments (noise and speaker) compared to the state-of-art methods with low computational cost.
\bibliographystyle{IEEEtran}
