Group Communication With Context Codec for Lightweight Source Separation

Despite the recent progress on neural network architectures for speech separation, the balance between the model size, model complexity and model performance is still an important and challenging problem for the deployment of such models to low-resource platforms. In this paper, we propose two simple modules, group communication and context codec, that can be easily applied to a wide range of architectures to jointly decrease the model size and complexity without sacrificing the performance. A group communication module splits a high-dimensional feature into groups of low-dimensional features and captures the inter-group dependency. A separation module with a significantly smaller model size can then be shared by all the groups. A context codec module, containing a context encoder and a context decoder, is designed as a learnable downsampling and upsampling module to decrease the length of a sequential feature processed by the separation module. The combination of the group communication and the context codec modules is referred to as the GC3 design. Experimental results show that applying GC3 on multiple network architectures for speech separation can achieve on-par or better performance with as small as 2.5% model size and 17.6% model complexity, respectively.


I. INTRODUCTION
Recent developments in the neural network architectures have significantly advanced the state-of-the-art for source separation performance.While researchers have shown that large neural networks can achieve superb performance on various machine learning problems, one important topic for network design, especially for the source separation problem, is to constrain the model size and complexity so that such models can be properly deployed to low-resource platforms such as mobile and hearable devices.
Tremendous efforts have been made to propose novel model architectures and model compression techniques.Early deep neural networks used for source separation contained stacked recurrent layers such as LSTM layers with a relatively large number of hidden units [1]- [4], and the corresponding model sizes were typically over tens of millions of parameters with high model complexity.Convolutional neural networks (CNNs) have also been explored in both time-frequency domain [5]- [8] and time domain [9]- [16], and researchers have begun to focus on decreasing the model size and complexity while maintaining or improving the performance.Moreover, the combination of recurrent and convolutional layers has also been a popular topic for real-time model design, and various convolutional recurrent networks have been proposed [17]- [21].Better layer organization within the network have also been investigated [22]- [25], which can further decrease the overall model size and maintain the separation fidelity.Beyond directly designing smaller models, neural architecture search (NAS) techniques have also been utilized to automatically search for compact architectures for speech-related tasks [26], [27], teacher-student learning methods have been explored for obtaining low-latency separation models [28], quantization and binarization algorithms have been studied for low-resource separation systems [29]- [31], and network pruning and distillation strategies can further be applied to decrease the model size [32], [33].However, compared with directly designing lightweight architectures, existing model compression or quantization techniques typically introduce different levels of degradation on the model performance [34], and the tradeoff between the complexity and performance drop needs to be carefully considered.Thus, finding smaller and better architectures is still preferred.
Our recent study introduced group communication (Group-Comm) [35], a module motivated by subband and multiband processing network architectures such as frequency-LSTM (F-LSTM) [36]- [39], which can easily change a separation model into a lightweight counterpart.GroupComm splits a highdimensional feature, such as a spectrum, into groups of lowdimensional features, such as subband spectra, and uses the same separation model across all the groups for weight sharing.Another inter-group module is applied to capture the dependencies within the groups, so that the processing of each group always depends on the global information available.Compared with conventional F-LSTM or other similar architectures that explicitly model time and frequency dependencies where the subband features are concatenated back to the fullband feature [40]- [42], GroupComm does not perform such concatenation but simply applies a small module to communicate across the groups.Moreover, the low-dimensional features enable the use of a smaller module, e.g., a CNN or RNN layer, than the original high-dimensional feature, and together with weight sharing the total model size can be significantly reduced.Experimental results showed that the GroupComm-equipped model can achieve on-par performance with the baseline model in the noisy reverberant speech separation task with a 2.8% model size and 43.5% multiply-accumulate (MAC) operations [43], a common metric for evaluating model complexity.
It is worth noting that although GroupComm can drastically decrease the model size, model complexity is still relatively high.Moreover, memory footprints in several GroupCommequipped models with small group sizes are higher than those in the baselines due to the additional computation introduced by the GroupComm modules, which may not only pose constraints on its applications but also increase the training cost.In this paper, we introduce a context codec module arXiv:2012.07291v2[eess.AS] 16 May 2021 to help GroupComm maintain the performance while further decreasing the number of MAC operations, accelerating the training speed and alleviating the memory consumption in both training and inference time.A context codec module contains a context encoder and a context decoder, where the context encoder summarizes the temporal context of local features into a single feature representing the global characteristics of the context, and a context decoding module transforms the compressed feature back to the context features.Squeezing the input contexts into higher-level representations corresponds to a nonlinear downsampling step that generates context-level embeddings and significantly decreases the length of a feature sequence.Note that compared with other architectures that perform iterative downsampling and upsampling steps [9], [15], the context codec is only applied once and all remaining modeling steps are applied on the downsampled features, which enables a smaller memory footprint and faster training speed.We call the combination of GroupComm and Context Codec the GC3 design.
The original GroupComm module applied a bidirectional LSTM (BLSTM) layer for inter-group processing.In this paper, we also explore different architectures for the GroupComm module and investigate the effect of different hyperparameters in the system configuration.Moreover, to validate the effect of GC3 on different network architectures, we select three other separation modules beyond the original dual-path RNN (DPRNN) baseline [22] applied in our previous work on GroupComm: two other CNN-based architectures, namely the temporal convolutional network (TCN) [11] and the sudo rm -rf network [15], and one transformer-based architecture, namely the dual-path transformer network (DPTNet) [24].Experimental results show that the GC3-equipped DPRNN can achieve on-par performance with the baseline DPRNN with 4.7% model size and 17.6% MAC operations, the GC3equipped CNN-based models can significantly improve the overall performance with as few as 2.5% model size and 33.7% MAC operations, and the GC3-equipped transformer-based model can maintain on-par performance with 4.6% model size and 17.7% MAC operations.These results indicate that GC3 has the potential to be a plug-and-play module suitable for a wide range of architectures.
The rest of the paper is organized as follows.Section II introduces the GC3 design and discusses the applicable model architectures.Section III provides the experiment configurations.Section IV analyzes the experimental results.Section V concludes the paper.

A. Standard Pipeline for Speech Separation
We start with a brief overview of a standard pipeline for speech separation.Given the input mixture waveforms x ∈ R P ×L where P denotes the number of available channels and L denotes the waveform length, an encoding transformation is typically applied to each channel to generate a 2-D representation: where where N denotes the representation dimension and T denotes the number of frames or time steps, and E(•) is the encoding transform.We assume a single-channel separation setting with P = 1 and drop the subscript where there is no ambiguity.For frequency-domain methods, E(•) denotes the short-time Fourier transform (STFT).For certain time-domain methods such as the time-domain audio separation network (TasNet) [11], [44], E(•) denotes a 1-D convolutional layer and H i becomes a real-valued representation.
H is then passed to a separation module to generate X outputs { Ĥc } X c=1 ∈ C N ×T corresponding to the X target representations: ) where T (•) is the mapping defined by the separation module.In most recent speech separation networks, T (•) is defined by certain sequence modeling neural networks such as deep longshort term memory (LSTM) networks [45], 1-D convolutional neural networks [11], or Transformers [24].
A decoding transform D(•) is then applied to all Ĥc to reconstruct the estimated target waveforms {s c } X c=1 ∈ R 1×L : Similarly, D(•) denotes the inverse short-time Fourier transform (ISTFT) in frequency-domain methods and denotes a 1-D transposed convolutional layer in TasNet-style methods.Figure 1 (A) presents the separation part in this pipeline.

B. Group Communication
Every frame in H, denoted by h ∈ R N , can be decomposed into K groups of lower-dimensional feature vectors {g i } K i=1 with g i ∈ R M .When there is no overlap between the groups, we have N = KM .A group communication (GroupComm) module is applied across the group of vectors to capture the inter-group dependencies: ) where ĝi ∈ R P is the transformed feature vector for group i, and F (•) is the mapping function defined by the module.Instead of concatenating {ĝ i } K i=1 back to an N -dimensional feature, ĝi are independently passed to a smaller separation module to save the model size and complexity.In other words, all groups share a same separation module whose width can be significantly smaller than the original separation module applied to H.

C. GroupComm with Context Codec
In TasNet-style time-domain methods, the 1-D convolutional waveform encoder contains a much smaller window length than standard frequency-domain methods, and it has been studied that shorter window length can lead to a better separation performance [11], [22].However, a shorter window length leads to a larger T which increases both the computational complexity and the modeling difficulty of the separation module.Our prior study showed that although GroupComm allowed a smaller separation module, the computation introduced by the GroupComm modules can still be large since the GroupComm module has to be applied to all the frames in H [35]. How to decrease T while maintaining the model performance is thus an important question.
A context codec is proposed here as a pair of encoding and decoding modules, which compress the context of feature vectors into a single summarization vector and decompress the vector back to a context, respectively.A context encoder splits H along the temporal dimension into blocks {D i } R i=1 ∈ R N ×C , where C denotes the context size and R denotes the number of context blocks.Each D i is then encoded into a single vector p i ∈ R W by the context encoder, resulting in a sequence of vectors P {p i } R i=1 ∈ R W ×R with R T .Any separation module can then be applied to P instead of H to save the computational cost.The transformed sequence of features are denoted as P ∈ R W ×R , and a context decoding module adds pi to each time step in D i and applies a nonlinear transformation to generate We select a deep residual BLSTM network for both the context encoder and decoder in our configuration.The deep residual BLSTM networks contained stacked BLSTM layers, where each BLSTM layer contains a linear projected layer connected to its output to match the input and output feature dimensions.A layer normalization (LayerNorm) operator [46] is added to the transformed output, a residual connection is added between the input to the BLSTM layer and the LayerNorm-normalized output, and the feature is then served as the input for the next layer.In the context encoder, a context block D i is passed to the GroupComm-equipped deep residual BLSTM network to generate a transformed sequence of features Q i ∈ R N ×C , and a mean-pooling operation is applied on Q i across the temporal dimension to obtain p i .In the context decoder, pi is added to each time step in D i and passed to the GroupComm-equipped deep residual BLSTM network to generate the final output Di .To save the computational cost in the context codec, GroupComm is also applied to the deep residual BLSTM networks in the same way as Eq. 4. This combination of GroupComm and context codec gives us the GC3 design, and Figure 1 (C) provides the flowchart for the GC3-equipped separation pipeline.
Note that there is no guarantee that the context encoding and decoding modules are reconstructing the original input features as a "codec" typically does, and here, we borrow the name of codec simply to represent the encoding and decoding properties of the two modules.

D. Discussions
Splitting a high-dimensional feature into low-dimensional sub-features has also been investigated in architectures for computer vision tasks [47]- [49].GroupComm shares the same principle as those designs for exploring the nonlinear dependendies at the sub-feature level, while GroupComm removes the feature concatenation operation and assumes that a small module shared by all the groups is adequate to preserve the model capacity given the inter-group modeling step.
As discussed in [35], the network width in the separation module in Figure 1 depends on the group size K. Empirically, we linearly decrease the network width as K increases.To provide an example, we assume that for a standard separation module in Figure 1 (A) with N -dimensional input features, the network width of the separation module is denoted by Q and both N and Q are multiples of K.By assuming that there is no overlap between groups, the input dimension for both the GroupComm module and the separation submodule (denoted by possible choices of architectures in Figure 1 (B) and (C)) is defined by M = N/K, and we can empirically set the network width to Q/K. [35] already conducted experiments on the effect of hyperparameters on the overall model performance and MAC operations, and it was observed that to achieve onpar performance with the baseline, a smaller K requires a deeper separation module.We show in Section IV that the GC3-equipped pipeline requires a slightly deeper separation module due to the existence of the context codec modules; however, the total number of MAC operations is fewer due to the shorter sequence length R after context encoding.
Context information is widely used as auxiliary information to assist the modeling of a center frame in a sequential input.While many existing studies use a plain concatenation of context features [1], [50], [51], context codec modules have also been investigated in various studies to learn a compact representation [52]- [55].Specifically, [56] applied a context codec for the multichannel separation task to learn a set of context-aware filters; however, the context codec did not decrease the sequence length T but was only used to capture context-aware information.The computational cost in [56] is thus even higher than that without context codec.The main role of the context codec in the GC3 framework is to decrease the computational cost in the actual sequence modeling module by decreasing the sequence length.

III. EXPERIMENT CONFIGURATIONS A. Data Simulation
We use the same dataset proposed in [57] for the singlechannel noisy reverberant speech separation task.The simulated dataset contains 20000, 5000 and 3000 4-second long utterances sampled at 16 kHz sample rate for training, validation and test sets, respectively.For each utterance, two speech signals and one noise signal are randomly selected from the 100-hour Librispeech subset [58] and the 100 Nonspeech Corpus [59], respectively.The overlap ratio between the two speakers is uniformly sampled between 0% and 100%, and the two speech signals are shifted accordingly and rescaled to a random relative SNR between 0 and 5 dB.The relative SNR between the power of the sum of the two clean speech signals and the noise is randomly sampled between 10 and 20 dB.The transformed signals are then convolved with the room impulse responses simulated by the image method [60] using the gpuRIR toolbox [61] for all microphones.The length and width of all the rooms are randomly sampled between 3 and 10 meters, and the height is randomly sampled between 2.5 and 4 meters.The reverberation time (T60) is randomly sampled between 0.1 and 0.5 seconds.After convolution, the echoic signals are summed to create the mixture for each microphone.The data simulation scripts are publicly available online1 .

B. Model Configurations 1) Separation Pipeline Configurations:
We test GC3 on the single-channel separation task, where only the first channel in the aforementioned dataset is used.We apply the TasNetstyle time-domain separation configuration where a linear learnable 1-D convolutional encoder is used to learn the 2-D sequential representations H, and a linear learnable 1-D transposed convolutional decoder is used to reconstruct the waveforms.The separation is done by estimating a set of multiplicative masks applied to the 2-D representation of the input mixture.We use a 2 ms window size (32 samples at 16 kHz sample rate) in the 1-D convolutional encoder and decoder for all experiments, and use ReLU nonlinearity as the activation function for the mask estimation layer.In models with GroupComm, the mask estimation layer is applied to different groups in parallel.
2) GroupComm Module Configurations: The original GroupComm module proposed in [35] applied a simple bidirectional LSTM (BLSTM) layer.However, the assumption that a sequential order exists in the features in different groups is ad-hoc.Here we investigate two other architectures for the GroupComm module: 1) Transform-average-concatenate (TAC) [57]: TAC was proposed for the multichannel speech separation task with ad-hoc microphone arrays where no microphone indexing or geometry information is known in advance.The design particularly matches our need in the GroupComm module where "group indices", i.e., the sequential order of the features in different groups, does not exist.For the group of features {g i } K i=1 , a fully-connected (FC) layer with parametric rectified linear unit (PReLU) activation [62] is applied for the transformation step: where P (•) is the mapping function defined by the first FC layer and f i ∈ R D denotes the output for group i.All f i are then averaged and passed to the second FC layer with PReLU activation for the averaging step: where R(•) is the mapping function defined by the second FC layer and f ∈ R D is the output for this step.f is finally concatenated with the output of the transformation step, f i , and passed to a third FC layer with PReLU activation to generate the final output ĝi : ) where S(•) is the mapping function defined by the third FC layer and [x; y] denotes the concatenation operation of vectors x and y.A residual connection is finally added between the module input g i and output ĝi .2) Multi-head Self Attention (MHSA) [63]: MHSA is widely used in various sequence modeling tasks and has already proven its effectiveness in multiple speechrelated problems [63]- [67].MHSA explicitly models the relationship between each pair of group features and thus can capture sequence-level dependencies.Following the standard definition of MHSA, we rewrite the concatenation of group features {g i } K i=1 as a matrix G ∈ R K×M and apply a MHSA layer: where n is the number of attention heads, n are the linear transformations for query, key and value, respectively, H n ∈ R K×d k is the output at head n, and W o is the linear transformation matrix for the output.Both the concatenation operation and the Softmax nonlinearity are applied across the attention heads.G is then passed to an FC layer with PReLU activation for further transformation, and another FC layer follows to generate the final output with the same shape as input G ∈ R K×M .We select the hyperparameters for the three architectures such that they all have a same number of parameters.The configuration of the modules is introduced in Section IV-B.
3) Separation Module Configurations: To investigate the effect of GC3 on different network architectures, we adopt 4 types of separation modules in our experiments: 1) Dual-path RNN (DPRNN) [22]: A dual-path RNN (DPRNN) segments a sequence of features into overlapping blocks and iteratively applies an intra-block BLSTM layer and an inter-block BLSTM layer to capture the local and global dependencies, respectively.DPRNN is also the architecture selected in our prior work on GroupComm [35].2) Temporal convolutional network (TCN) [11]: A TCN block contained a depthwise-separable convolution layer [68] with PReLU nonlinearity and a LayerNorm operation, where the convolution layer contains an exponentially increased dilation factor to increase the overall receptive field of the TCN. 3) Sudo rm -rf [15]: Sudo rm -rf proposed a U-net style convolutional block where multiple levels of downsampling and upsampling layers were applied to extract features at different scales.Each downsampling layer contained a depthwise separation convolution operation similar to Conv-TasNet, and each upsampling layer contained a bilinear interpolation operation.4) Dual-path Transformer (DPTNet) [24]: DPTNet replaced the BLSTM layers in DPRNN with modified Transformer layers [63], where the fully connected layer in the default transformer encoder layer [63] was replaced by an LSTM layer to learn the positional information in the sequence.We encourage the readers to refer to the corresponding literature for details about these architectures.All separation modules share a same configuration for the encoder and decoder and the mask estimation layer.The implementation of all models with GC3 is available online2 .

C. Training Configurations
All models are trained for 100 epochs with the Adam optimizer with an initial learning rate of 0.001.Negative signal-tonoise ratio (SNR) is used as the training objective for all models.The learning rate is decayed by 0.98 for every two epochs.Gradient clipping by a maximum gradient norm of 5 is always applied for proper convergence.Early stopping is applied when no best validation model is found for 10 consecutive epochs.No other training tricks or regularization techniques are used.Auxiliary autoencoding training (A2T) is applied to enhance the robustness on this reverberant environment configuration [69], where the multiplicative mask estimated for each target is also applied to the corresponding direct-path signal, and the auxiliary autoencoding loss is applied to ensure that the multiplicative mask maintains the direct-path signal.For more details about A2T, we recommend the readers to refer to the original literature.

D. Evaluation metrics
In the experiments for hyperparameter search, we report the SI-SDR score [70] for the evaluation of the separation performance, and the model size and the number of MAC operations (MACs) as metrics for model complexity.MACs for all models are calculated by an open-source toolbox 3 .In the experiments for comparing the performance of different separation modules with and without GC3, we also report the wideband perceptual evaluation of speech quality (PESQ) score [71] and the short-time objective intelligibility measure (STOI) [72].

IV. RESULTS AND ANALYSIS
In this section, we first evaluate the performance of GroupComm-equipped DPRNN-TasNet and GC3-equipped DPRNN-TasNet by comparing to the baseline DPRNN-TasNet.We then select the best GC3 configuration and investigate the  effect of different configurations in the GroupComm module.
After that, we change DPRNN to three other types of separation modules and validate the performance of GC3 on various architectures.

A. Experimental Results on GC3-DPRNN
Our previous study [35] conducted experiments on the effect of GroupComm in the DPRNN-TasNet architecture.A residual BLSTM layer identical to the one used in the context codec was selected for the GroupComm module in [35], and we present the experimental results on the comparison between original DPRNN-TasNet, the GroupComm-equipped DPRNN-TasNet, and the GC3-equipped DPRNN-TasNet.Table I shows the hyperparameter notations used in the DPRNN-based models.Note that H i and H o represent the input and output dimensions of all the BLSTM layers throughout the network since all context codec, GroupComm and DPRNN blocks use residual BLSTM as basic building units.Table II lists the separation performance and the corresponding model size and complexity for the three types of models.The first half of the table is identical to the experiment results presented in [35].
For the standard DPRNN model, a linear bottleneck FC layer is applied to H to transform the N -dimensional feature to H idimensional feature.For all GroupComm-equipped models, H is split into groups and then directly sent to the context encoder without the bottleneck layer.
We first notice that when the number of groups K is small (e.g.K ≤ 4), the GroupComm-DPRNN models can achieve higher performance than plain DPRNN with smaller model size at the cost of an on-par or higher model complexity.This is due to the extra MAC operations introduced by the GroupComm module.A larger number of groups K leads to fewer MAC operations; however, the depth of the model has to be modified accordingly to maintain the performance.We explore different hyperparameter settings such that for each value of K we obtain a model with less than 5% relative performance degradation.Among all the GroupComm-DPRNN models, we find that the model with K = 16, N = 128 and L s = 6 achieves on-par performance as the standard DPRNN model with 2.8% model size and 43.4% MAC operations, and the model with K = 32, N = 128 and L s = 10 only has 5% performance degradation with 1.4% model size and 41.2% MAC operations.These models show that GroupComm is effective in decreasing both the model size and complexity without sacrificing the performance.Moreover, we also conduct experiments on the effect of model width in terms of number of encoder filters N and network width Q (i.e., H o in DPRNN-based models) and observe that increasing model width can improve the performance with a much shallower architecture; however, the model complexity can be relatively high.For example, a performance improvement of 0.7 dB can be achieved by K = 16, N = 256 and L s = 4, while its number of MAC operations is even higher than the baseline DPRNN.This indicates that when the computational cost is not a bottleneck, GroupComm can also be applied to improve the overall performance.
For the GC3-based models, we first investigate the balance between model complexity and performance with different context sizes C. A larger context size C leads to fewer frames for the sequence modeling module, and a smaller DPRNN block size B can be applied to save model complexity.We observe that models with C = 32, 16 and 8 have almost the same performance while differing greatly in complexity; hence, we choose C = 32 for all other experiments.For K = 8, we see that increasing the number of context codec layers can improve the separation performance, implying that a strong context codec is important.The on-par performance can be achieved by K = 16, N = 128, L s = 8 and L c = 2 with a 4.7% model size and 24.4% MAC operations, which saves 19% more MAC operations compared with the GroupComm-only model.The GC3-based model with 5% performance degradation has the configuration of K = 32, N = 128, L s = 14 and L c = 2, which saves 25% more MAC operations than the GroupCommonly model.Such results prove that GC3-based models are more effective than GroupComm-only models thanks to the context compression operation.Similarly, increasing the model width can also lead to better overall performance with a shallower architecture at the cost of complexity, and in such configurations it is empirically better to keep the depth of the context codec according to the results for K = 16.

B. Effect of Model Architectures for GroupComm
We then evaluate the effect of model architectures for GroupComm.We compare BLSTM with the two other models introduced in Section III-B2.For the TAC architecture, the hidden dimension D is set to 3H o .For the MHSA architecture, we use 4 attention heads with the hidden dimension d k set to M .Such configurations are applied to match the overall model sizes with a residual BLSTM layer.We use the hyperparameter configurations of the two GC3-based models marked in bold in Table II with K = 16 and 32, respectively.Table III shows the comparison of the three architectures.We find that although MHSA achieves on-par performance as BLSTM in both configurations, TAC obtains even better performance with the fewest MAC operations.Since the number of MAC operations in TAC is fewer than those in both BLSTM and MHSA and the transformation and concatenation steps in TAC can be run in parallel across groups, we use TAC as the default module for GroupComm in all remaining experiments.

C. Effect of Overlap between Groups
The default group segmentation configuration in all experiments above assumes no overlap between groups.However, since a 50% overlap is applied in both context codec and the sequence segmentation process in DPRNN, it is thus interesting to see whether adding overlap between groups can improve the performance.Table IV provides the separation performance as well as the model size and complexity for different overlap ratios between groups.We observe that adding a 25% percent overlap between groups increases the number of MAC operations while not leading to an better performance, but a 50% overlap between groups can improve the overall performance.Compared with the model in Table II with a similar performance (K = 8, N = 128, L c = 2), such a model has a smaller model size and fewer MAC operations.This shows that compared with using a smaller number of groups K, adding proper overlap between groups is a more effective method for improving the performance.

D. Effect of GC3 in Different Separation Modules
To evaluate GC3 on the three other separation modules described in Section III-B3, we select the hyperparameters so that all four models have on-par model size when no GroupComm or context codec are applied: 1) TCN: We apply 2 TCNs with 6 convolutional blocks in each TCN.We use the same number of TCN layers and convolutional blocks for the GC3-equipped modification.2) Sudo rm -rf : We use the default configuration, which contains 5 downsampling and upsampling layers in each U-net block, and we use 8 blocks for both baseline and GC3-equipped modification.3) DPTNet: We use the default configuration that contains 6 Transformer layers, and for GC3-equipped DPTNet we use 8 Transformer layers similar to our configuration for GC3-DPRNN.The learning rate warm-up configuration is also set the same as the recommended configuration, where the first 4000 iterations are used for the warm-up stage.The other hyperparameters are kept the same as the selected best GC3-DPRNN model in Table III.Table V presents the separation performance as well as the model size and complexity of the four architectures with their GC3-equipped modifications.We first compare the performance of the baseline models without GC3.The plain DPRNN architecture achieves the best performance among the four architectures and is even better than the plain DPTNet, which indicates that transformer-based architectures might not be always superior than recurrent neural networks.TCN does not have satisfying performance because of the limited receptive field in our configuration (253 frames or 0.253s), as it has been shown that large receptive fields for TCN lead to better separation performance [11].Although the selected Sudo rm -rf configuration has a large enough receptive field to cover the entire sequential feature, it obtains an even worse separation performance with on-par model size and complexity as the TCN architecture.Although [15] reported that the Sudo rm -rf architecture achieved constantly better performance than DPRNN and TCN architectures, the results here indicates that its performance on the more challenging noisy reverberant environments needs to be revised.Moreover, although all four architectures achieve significant SI-SDR improvement with respect to the unprocessed mixture, the improvement on wideband PESQ and STOI scores are moderate.One possible reason for this phenomenon is the inconsistency between the time-domain and frequency-domain evaluation metrics [11], as all the models are trained with the time-domain objective (negative SNR) while the calculation of PESQ and STOI are both in frequency domain.
We then compare the separation performance and the model size and complexity on the GC3-equipped architectures.For DPRNN and DPTNet, GC3-equipped modifications can achieve a same level of separation performance with significantly smaller model sizes and number of MAC operations.For CNN-based architectures (TCN and Sudo rm -rf), GC3equipped modifications can further achieve significantly higher SI-SDR scores.Since the context codec squeezes the long sequence by a factor of C/2 (16 for C = 32), the effective temporal receptive field of the TCN separator is significantly larger (0.253 × 16 = 4.05s) and thus can better capture the temporal dependencies.Since it has also been reported in [15] that a deeper Sudo rm -rf architecture can lead to better overall separation performance, introducing GC3 to Sudo rm -rf might also be equivalent to increasing the model depth and improves the performance.More in-depth analysis on the reason behind the performance improvements in different architectures is left for future work.Nevertheless, the results prove that GC3 can be easily deployed in to various architectures and maintain its effectiveness.
Beyond the model size and number of MAC operations, the memory footprint and the training and inference speed are also important indicators for model complexity, as small models can also be slow and require enormous memory.To compare such training and inference phase statistics of different models, we evaluate the batch-level training and inference phase memory footprints and running speeds on a single NVIDIA TITAN X Pascal graphic card with a batch size of 4. The memory footprint is calculated via an opensource toolbox [73].We observe that the GC3-equipped models, e.g.DPRNN and TCN, increase the training phase memory footprint but do not affect the training speed, and an acceleration can even be observed in the GC3-equipped TCN model.The inference phase memory footprint for all four architectures with GC3 applied are significantly lower than the ones without GC3, however the inference speed are all on-par or only slightly faster than the baselines.The reason for this might be because the effective model depth for a GC3-equipped model is larger than the baseline which prevents the model from easy parallelization.The results show that although the number of intermediate outputs introduced by the deeper separation module and the GroupComm modules may increase the training phase memory footprint, GC3 can always decrease the inference phase memory footprint without sacrificing the inference speed.

V. CONCLUSION AND FUTURE WORKS
In this paper, we proposed Group Communication with Context Codec (GC3), a simple module for significantly decreasing both the model size and complexity while maintaining the performance and inference speed in various speech separation network architectures.The group communication (Group-Comm) module in GC3 splits a high-dimensional feature into groups of low-dimensional features and applies a module to capture the inter-group dependency.Instead of concatenating the low-dimensional features back to a high-dimensional feature for further processing, a model with a significantly smaller width is shared by all groups and run in parallel.A context codec is applied to decrease the length of a sequential feature and thus decrease the complexity of the sequence modeling module.A context encoder compresses the temporal context of local features into a single feature, and a context decoder decompresses the transformed feature back to the context features.We conducted experiments on four different types of separation module architectures and showed that adding GC3 to the baselines led to on-par or better separation performance with significantly smaller model sizes and complexity without sacrificing the inference speed, proving that GC3 can be easily deployed to a wide range of architectures to change them into their lightweight counterparts.
For future works, we would like to investigate three important and interesting topics.The first topic is about the application of GC3 in other tasks beyond speech separation, which is a straightforward extension of the experiment configurations presented here.The second topic is to apply model binarization and quantization techniques together with GC3 to create models with even smaller model size and complexity.The third topic is to use GC3 as a prototype module and utilize neural architecture search (NAS) algorithms to search for model architectures and module organizations that better balance the model size, complexity, speed and performance.

VI. ACKNOWLEDGMENTS
This work was funded by a grant from the National Institute of Health, NIDCD, DC014279; and a grant from Marie-Josée and Henry R. Kravis.

Figure 1 (
B) presents the flowchart for a GroupComm-equipped separation module.

Fig. 1 .
Fig.1.Flowcharts for (A) standard sequence processing pipeline with a large sequence modeling module; (B) GroupComm-equipped pipeline, where the features are split into groups with a GroupComm module for inter-group communication.A smaller module for sequence modeling is then shared by all groups; (C) GC3-equipped pipeline, where the sequence is first segmented into local context frames, and each context is encoded into a single feature.The sequence of summarized features is passed to a GroupComm-equipped module in (B).The transformed summarized features and the original local context frames are passed to a context decoding module and an overlap-add operation to generate the output with the same size as the input sequence.

TABLE III .
COMPARISON OF GC3-DPRNN MODELS WITH DIFFERENT MODEL ARCHITECTURES FOR GROUPCOMM.

TABLE IV .
EFFECT OF GROUP OVERLAP RATIO ON MODEL COMPLEXITY AND SEPARATION PERFORMANCE IN GC3-DPRNN MODELS.

TABLE V .
COMPARISON OF DPRNN, TCN, SUDO RM -RF, AND DPTNET ARCHITECTURES WITH AND WITHOUT GC3.THE TRAINING AND INFERENCE PHASE STATISTICS ARE EVALUATED WITH A BATCH SIZE OF 4.