Multi-Frame Cross-Entropy Training for Convolutional Neural Networks in Speech Recognition

TL;DR

This paper proposes Multi-Frame Cross-Entropy training for CNNs in speech recognition, enabling the model to learn from multiple frames simultaneously, leading to significant word error rate improvements on benchmark datasets.

Contribution

It introduces a novel training method that leverages multiple frames at once for CNN acoustic models, enhancing learning efficiency and accuracy.

Findings

Large WER reductions on hub5 and rt02 datasets

Effective multi-frame training with minimal additional computation

Improved speech recognition performance on Switchboard benchmark

Abstract

We introduce Multi-Frame Cross-Entropy training (MFCE) for convolutional neural network acoustic models. Recognizing that similar to RNNs, CNNs are in nature sequence models that take variable length inputs, we propose to take as input to the CNN a part of an utterance long enough that multiple labels are predicted at once, therefore getting cross-entropy loss signal from multiple adjacent frames. This increases the amount of label information drastically for small marginal computational cost. We show large WER improvements on hub5 and rt02 after training on the 2000-hour Switchboard benchmark.

Full text

Index Terms: CNN, acoustic modeling, multi-frame, cross-entropy, MFCE

1 Introduction

We will study training of Convolutional Neural Networks (CNNs) as acoustic models in hybrid NN/HMM speech recognition. This paper focuses on the frame-by-frame cross-entropy training stage, where we will cheaply process additional neighboring frames to predict multiple adjacent HMM targets at the same time.

An important property of CNNs we will leverage in this work, is that they can efficiently process sequences from varying length [1, 2]. This property was explored for efficient sequence training of CNN acoustic models in hybrid NN/HMM speech recognition [3, 4]. We will heavily rely on this “dense prediction” or “sequence prediction” viewpoint in this paper, which we will review in section 2. Proper implementation of CNNs for sequences allows processing additional neighboring frames at minimal computational cost.

Even though end-to-end models have gained in popularity in recent years, the hybrid approach still has state of the art performance on well-respected large benchmark datasets [5, 6]. Additionally, hybrid models have properties which can be desirable in certain applications: principled combination with language models can help for transfering trained models to new domain specific languages, the interpretable HMM states enable easy adaptation to keyword search [7] where many low-confidence hypotheses need to be considered, etc. Furthermore our work relies on CNNs as variable-length sequence classification models [1], which has been adapted to end-to-end setting [8, 9]. This paper does not immediately translate to the end-to-end setting, however the core idea of processing small chunks of the utterance to get label information of part of the utterance has been adapted to the end-to-end setting [10].

For RNN acoustic models in hybrid speech recognition [11], it is standard to use all labels of a window during CE training [6, 5]. This is natural since the RNN does not reduce utterance length and generates an output for each input frame.

The rest of this paper is organized as follows: Section 2 reviews prior work on using CNNs for sequence prediction, Section 3 reviews standard cross-entropy vs sequence training in hybrid speech recognition, and Section 4 introduces our new multi-frame CE training. Related work is in Section 5 and experiments showing the computational and WER gains of MFCE are presented in Section 6.

2 Sequence prediction with CNNs

The traditional hybrid NN/HMM viewpoint sees CNNs as a specific type of DNNs which process a fixed context of frames and predicts the target of the center frame. RNNs at the other hand are capable of processing variable length utterances. In this section we review the most important papers that challenge this viewpoint and present CNNs from the perspective of variable-length sequence processing.

Standard DNN acoustic models [12] predict the phonetic content of a single frame, taking as input the frame with some surrounding number of context frames on the left and right. Traditional DNN models require fixed context windows and flatten the features before processing. During (cross-entropy) training, random frames from different utterances and speakers are assembled into minibatches.

In contrast, TDNNs [13] and CNNs [1, 2] were originally conceived to process variable-length sequences, wherein a series of learned filters are convolved over the input data. In introduction of modern CNNs to large-scale speech recognition [14, 15] this viewpoint went somewhat lost; CNNs were typically described similar to DNNs, taking a fixed context window and predicting the target of the center frame only.

To adapt modern CNNs to ASR, three aspects need some care. Firstly, before the output layer, the convolutional pathway feeds into a stack of fully connected (FC) layers. FC layers on first sight look like a problem since in their typical implementation they need a fixed size input vector, thus a fixed size context. However it has been pointed out [16, 4] that FC layers are equivalently implemented as $1{\mathbf{x}}1$ convolutions, except for the first one in which the kernel size equals the output size of the convolutional pathway (e.g. acts as a flattening operation). This avoids the use of any pooling in order to flatten the output of the convolutional stack.

Secondly, in the domain of speech, [3] says to avoid padding the convolutional layers in the time dimension, as this would prevent efficient full-utterance processing at test time. Due to this, in each convolutional layer with square kernel of size $k$ the input sequence is reduced in time by $k-1$. This explicitly ties the number of convolutional layers to the size of the context window needed to produce a single frame prediction. We will refer to this number of input frames for a single output prediction as the intrinsic model sequence length $l_{m}$. This type of model allows for efficient sequence prediction as the input sequence can be processed with a sliding window of stride 1, so that all neighboring computation from predictions on previous frames in the sequence are reused for the current frame.

Thirdly, for efficient sequence prediction with CNNs, we additionally replace pooling in time with time-dilated convolutions [4, 17]. The reason to avoid pooling in time is that with $p$ pooling operations of stride $s$ in time, the number of output frames will be reduced by a factor of $s^{p}$. To perform sequence training, we require the resolution of the output not be downsampled. This is possible by requiring time-stride $s=1$ everywhere (also pooling operations), and instead of time-pooling, we dilate the convolutional kernels by a factor of $s$ in the time direction. Dilation factors are cumulative through the network, giving the same $s^{p}$ behavior.

With this we now have an efficient, fully convolutional pathway from input sequence to output sequence predictions. An input of length $l_{m}$ will produce a single prediction: we name this quantity $l_{m}$ the intrinsic model sequence length. Processing a longer sequence $l_{i}>l_{m}$ will return predictions for the central $l_{i}-l_{m}+1$ frames. So to process a full utterance of length $l_{u}$, the input sequence is padded at beginning and end such that the CNN takes as input $l_{u}+l_{m}-1$ frames to predict $l_{u}$ output labels.

3 Cross-Entropy vs Sequence Training

In training a hybrid speech recognition system there are two phases. The first phase is cross-entropy (CE) training, in which input sequences of a fixed length are sampled from full utterances and randomly batched together. Let $f^{r}(t)\in{\mathbb{R}}^{3{\mathbf{x}}D}$ be the ($D=64$-dimensional logmel) features of the frame at time $t$ for utterance $r$ in the training dataset. Let each sample in a minibatch be (with $r,t$ randomly sampled) $\bm{x}^{r}(t)=[f^{r}(t-c),\dots,f^{r}(t),f^{r}(t+1),\dots,f^{r}(t+c)]\in{\mathbb{R}}^{3{\mathbf{x}}D{\mathbf{x}}l_{m}}$, where we introduced context $c$ such that $2c+1=l_{m}$). For each $\bm{x}^{r}(t)$ the CNN will produce the softmax output $s$ for the center frame: $s^{r}(t)\in{\mathbb{R}}^{S}$ with S being the number of states, i.e. label dimensionality. The CE loss (in this case reduces to NLL loss) is used to optimize $s^{r}(t)$: $\mathcal{F}=\sum_{r,t}\mathcal{F}^{r}(t)$ with per-sample CE loss $\mathcal{F}^{r}(t)=-\log[s^{r}(t)]_{k=y^{r}(t)}$, where the label $y^{r}(t)$ (coming from HMM forced alignment) provides the index $k\in[1\dots S]$ of the correct target.

The second phase is sequence training (ST) [18], where full utterances are processed by the network and a sequence-level objective is optimized (e.g. MPE [19] or bMMI [20] in our case). This discriminative ST objective is a much closer proxy to the actual objective Word Error Rate (WER) than the frame-level Cross-Entropy loss.

During ST with a correct CNN implementation, predictions are efficiently computed on the full sequence of frames simultaneously (dense predictions [4]). This greatly helps reduce the overall computational cost of training as duplicate operations are avoided by sharing most computation between neighboring frames.

4 MFCE: Multi-Frame CE Training

We can now introduce multi-frame cross-entropy training (or MFCE) for CNN acoustic models (Fig 1 vs 2). With multi-frame CE we process an input window of length $l_{i}$, which is $\delta$ longer than the intrinsic model sequence length $l_{m}$. Without any modifications to the CNN architecture, this will cause the CNN to output predictions for the center $1+\delta$ frames. Now we apply the CE loss to each of the center frames, using $1+\delta$ labels. We introduced $\delta=l_{i}-l_{m}$ the number of additional adjacent frames.

In MFCE training, the minibatch sample $r,t$ for utterance $r$ timestep $t$ is now $\delta$ longer: $\bm{x}^{r}(t)=[f^{r}(t-c),\dots,f^{r}(t+\delta+c)]\in{\mathbb{R}}^{3{\mathbf{x}}D{\mathbf{x}}l_{i}}$. The CNN predicts the sequence of $(1+\delta)$ softmax outputs $[s^{r}(t),\dots,s^{r}(t+\delta)]$. For this sample in the minibatch, the MFCE loss becomes $\mathcal{F}^{r}(t)=\frac{1}{1+\delta}\sum_{t^{\prime}=t}^{t+\delta}-\log[s^{r}(t^{\prime})]_{k=y^{r}(t^{\prime})}$.

Using MFCE we use $(1+\delta)$ more label data per sample in the minibatch, at minimal additional computational cost. For example, for a typical CNN which takes an input window of $l_{m}=53$ per prediction, we could add $\delta=8$ input frames (new input window $l_{i}=61$) to predict $9$ outputs at once. The additional computational cost is roughly $\delta/l_{m}=15\%$ while the amount of labels used for this input increased 9-fold.

Figure 1 and 2 show MFCE for a small CNN. Note that the only difference between regular CE and MFCE training is providing a longer sequence length at the CNN input; there are no architectural changes needed. The receptive field for each output is still the same $l_{m}$, however the receptive field and CNN internal states are highly overlapping for adjacent output frames.

However, by training on multiple adjacent frames we also expect to have high correlation between adjacent outputs since (a) the phonetic content will be similar, and (b) the signal comes from the same speaker. Therefore we expect the additional value of adjacent labels to be small in comparison to the labels from different samples in the batch with randomly sampled $r,t$. The strong correlation between the labels and speakers may hurt randomization needed in a minibatch during CE training. It is now an empirical question whether the marginal value of using the adjacent labels outweighs (a) the marginal cost of compute and (b) less random, more correlated labels.

Note that one concept requires extra care: the definition of an “epoch” or one pass through the data. In this work, we define an epoch of training as a single pass over all input frames in the data. This means that, for a dataset of length $L$ frames, we can chop the input into $N=L/l_{i}$ samples (or input windows). This results in $(\delta+1)N=\frac{(\delta+1)L}{l_{i}}=\frac{(\delta+1)L}{l_{m}+\delta}$ labels predicted in one pass over the entire dataset. In contrast, in the single-frame setting, with $\delta=0$, we are using less labels per epoch: only $N=\frac{L}{l_{m}}$.

5 Related work

Somewhat closely related to our work is [21], which proposes a multi-frame training strategy of DNN acoustic models. The approach in that paper relies on using a reduced framerate, and predicting multiple states from the same input window. Their underlying assumption is that the redundancy between adjacent input windows to predict adjacent phone states, is large enough to warrant downsampling the input windows by using stride $s\geq 2$ frames), and predict $s$ phone states from each input window.

In contrast to [21], since we process the utterance fully convolutionally, we do not need to reduce the framerate by using stride $>1$ to eliminate redundant computation. Rather the convolutional structure allows to immediately share computation between adjacent frames without reducing the input framerate, allowing our model to make use of all frames in the utterance for prediction without incurring any computational overhead.

Another closely related work is [22], where a framewise CE objective is added as regularization during ST. As noted in Sections 1 and 2, using multi-frame labels is standard during RNN acoustic model training.

6 Experiments

We show results with vgg-style CNNs [23] (with time dilation [4]) on $D=64$-dimensional logmel features with $\Delta,\Delta\Delta$ and output target space $S=32k$ tied CD states. All models are trained in PyTorch using SGD and Nesterov acceleration with momentum 0.99, learning rate 0.01, and $L_{2}$ weight decay $1e^{-6}$. We train for 16 epochs and clip gradients to $L_{2}$ norm 10. From epoch 10, we begin annealing the learning rate by a factor of $\sqrt{0.5}$ per epoch. Our model has an initial $5{\mathbf{x}}$ convolution followed by a stack of 12 $3{\mathbf{x}}3$ convolutions with 3 conv layers having output feature maps 64, 128, 256, 512 respectively. This architecture further follows [4] but with as FC layers ($1{\mathbf{x}}1$ convs) only a bottleneck (512 feature maps) and output layer (32k feature maps). By default models are trained on 2 gpus with batch size $2{\mathbf{x}}256$, but we present result with variation in: per-gpu batch size, total number of gpus, and model without time dilation, in Figure 4 and Table 2.

Figure 3 shows our main experimental result. In the left column we compare heldout NLL, and WER on Hub5 and rt02 against epochs; in the right column we compare against walltime (days). Each line is the same (model $a$ in Fig 4) with per-gpu batch size 256, trained on two gpus, and $l_{m}=53$, differing in $\delta=0,2,4,8,16$.

In Figure 3a, we see that heldout NLL is consistently improved as $\delta$ increases. This tracks with WER improvement for both Hub5 and rt02, as seen in Figures 3c and 3e, respectively. On the rt02 dataset, we see in Table 2 an absolute best WER of $14.5\%$ for $\delta=16$, a $0.8\%$ gain over the usual single-frame CE trained model and $0.3\%$ over $\delta=8$.

In the right column of Figure 3 we show the results in terms of training walltime (on 2 NVIDIA K80 GPU’s). From Figure 3b, we see that the NLL loss in terms of training time shows a trade-off: increasing $\delta$ increases compute time (but not proportional to $\delta$!). After 8 days of training, for example, the $\delta=4$ setup has best NLL, but eventually $\delta=8$ and $\delta=16$ achieve better results.

Note that as function of walltime there is a cross-over point where the $\delta=16$ losses go from being below, to being above the others. This can be attributed to learning rate decay starting later in terms of wall-time. Since for a doubling of $\delta$, we (approximately) use twice as much labels, we can probably decay the learning rate faster. Speeding up the schedule according to $(1+\delta)/(l_{m}+\delta)$ would be equivalent to keeping the schedule constant, in terms of number of labels processed. Somewhere in the middle between constant and this speed-up is probably optimal. We leave this for future work.

Figure 4 shows that our results hold across some hyper parameter variation and a simpler model architecture.

Tables 2 and 2 summarize the best WER/NLL values for each of the training runs from Figures 3 and 4, respectivey.

7 Discussion

We proposed MFCE for CNN acoustic models, and showed it gains significant WER performance for only a marginal increase in computational cost. In future work, we could explore full utterance cross-entropy training, which would require batching of utterances by length during CE training similar to ST training. We also suggest that an adaptation of the learning rate schedule (decaying faster for lager $\delta$) could mitigate the WER performance vs wall-time trade-off identified here, and train with large $\delta$ MFCE not only to better performance, but also faster. Lastly, one interesting extension is annealed MFCE in which $\delta$ is increased during training until we gradually reach full utterance lengths, and simultaneously gradually transitioning from CE to the discriminative ST (bMMI) objective, as opposed to switching from single-frame CE to full-utterance ST at a fixed point.