A Token-Wise Beam Search Algorithm for RNN-T

TL;DR

This paper introduces a token-wise beam search algorithm for RNN-T that batches joint network calls across segments, significantly improving decoding speed and accuracy in speech recognition.

Contribution

The proposed algorithm batches joint network calls across segments, leading to substantial speedups and improved word error rates compared to traditional time-step decoding methods.

Findings

Achieves 20%-96% decoding speedup across models

Improves oracle WER by up to 11% relative with larger segments

Slightly enhances general WER

Abstract

Standard Recurrent Neural Network Transducers (RNN-T) decoding algorithms for speech recognition are iterating over the time axis, such that one time step is decoded before moving on to the next time step. Those algorithms result in a large number of calls to the joint network, which were shown in previous work to be an important factor that reduces decoding speed. We present a decoding beam search algorithm that batches the joint network calls across a segment of time steps, which results in 20%-96% decoding speedups consistently across all models and settings experimented with. In addition, aggregating emission probabilities over a segment may be seen as a better approximation to finding the most likely model output, causing our algorithm to improve oracle word error rate by up to 11% relative as the segment size increases, and to slightly improve general word error rate.

Tables

Table 1. Table 1 : Librispeech model (test-other): decoding results with the standard algorithm (segment size 1) and our proposed token-wise beam search. In parentheses are the relative improvement % over the standard algorithm. Best throughput and OWER values are in boldface.

N-best	Segment	WER	OWER	Throughput	Throughput	Calls/	Joins/
	Size			CPU (f/s)	GPU (f/s)	Frame	Frame
2	1	8.66	8.15	192.12	439.56	1.41	1.41
	2	8.67 (-0.12%)	7.82 (4.05%)	220.27 (14.65%)	685.14 (55.87%)	0.75	1.50
	3	8.63 (0.35%)	7.69 (5.64%)	304.62 (58.56%)	861.02 (95.88%)	0.54	1.62
	5	8.62 (0.46%)	7.51 (7.85%)	200.64 (4.43%)	770.39 (75.26%)	0.38	1.90
	10	8.61 (0.58%)	7.41 (9.08%)	191.48 (-0.33%)	392.34 (-10.74%)	0.27	2.61
	20	8.59 (0.81%)	7.38 (9.45%)	114.41 (-40.45%)	133.56 (-69.62%)	0.20	3.91
	50	8.57 (1.04%)	7.27 (10.80%)	37.80 (-80.32%)	35.74 (-91.87%)	0.16	7.56
5	1	8.64	6.39	90.54	298.30	1.58	1.58
	2	8.64 (-0.00%)	6.19 (3.13%)	109.49 (20.93%)	455.42 (52.67%)	0.83	1.65
	3	8.6 (0.46%)	6.11 (4.38%)	127.37 (40.68%)	447.58 (50.04%)	0.60	1.78
	5	8.58 (0.69%)	5.95 (6.89%)	137.15 (51.48%)	370.06 (24.06%)	0.42	2.07
	10	8.6 (0.46%)	5.86 (8.29%)	93.57 (3.35%)	142.18 (-52.34%)	0.29	2.81
	20	8.58 (0.69%)	5.8 (9.23%)	52.34 (-42.19%)	61.06 (-79.53%)	0.21	4.16
	50	8.55 (1.04%)	5.76 (9.86%)	15.70 (-82.66%)	12.83 (-95.70%)	0.17	7.92
10	1	8.58	5.42	48.40	202.95	1.69	1.69
	2	8.57 (0.12%)	5.26 (2.95%)	67.44 (39.34%)	284.28 (40.07%)	0.89	1.77
	3	8.59 (-0.12%)	5.21 (3.87%)	82.84 (71.16%)	299.22 (47.44%)	0.64	1.90
	5	8.56 (0.23%)	5.16 (4.80%)	71.86 (48.47%)	187.29 (-7.72%)	0.45	2.21
	10	8.56 (0.23%)	5.1 (5.90%)	50.65 (4.65%)	77.13 (-62.00%)	0.30	2.95
	20	8.57 (0.12%)	5.07 (6.46%)	30.33 (-37.33%)	33.22 (-83.63%)	0.22	4.34
	50	8.57 (0.12%)	5 (7.75%)	7.35 (-84.81%)	7.30 (-96.40%)	0.18	8.20

Table 2. Table 2 : Large assistant model: decoding results with the standard algorithm (segment size 1) and our proposed token-wise beam search. In parentheses are the relative improvement % over the standard algorithm. Best throughput and OWER values are in boldface.

N-best	Segment	WER	OWER	Throughput	Throughput	Calls/	Joins/
	Size			CPU (f/s)	GPU (f/s)	Frame	Frame
2	1	8.71	7.48	244.91	618.23	1.28	1.28
	2	8.56 (1.72%)	7.3 (2.41%)	241.64 (-1.34%)	859.12 (38.96%)	0.74	1.46
	3	8.49 (2.53%)	7.22 (3.48%)	348.79 (42.42%)	978.77 (58.32%)	0.54	1.61
	5	8.41 (3.44%)	7.04 (5.88%)	350.63 (43.17%)	1,158.79 (87.44%)	0.35	1.71
	10	8.43 (3.21%)	6.98 (6.68%)	306.70 (25.23%)	702.09 (13.56%)	0.21	2.02
	20	8.35 (4.13%)	6.97 (6.82%)	221.90 (-9.40%)	275.44 (-55.45%)	0.13	2.54
	50	8.32 (4.48%)	6.82 (8.82%)	94.19 (-61.54%)	102.50 (-83.42%)	0.09	3.61
5	1	8.39	5.47	105.16	330.69	1.57	1.57
	2	8.35 (0.48%)	5.38 (1.65%)	128.45 (22.15%)	459.99 (39.10%)	0.91	1.81
	3	8.31 (0.95%)	5.31 (2.93%)	141.48 (34.54%)	515.16 (55.78%)	0.68	2.01
	5	8.29 (1.19%)	5.27 (3.66%)	136.85 (30.14%)	537.73 (62.61%)	0.43	2.13
	10	8.29 (1.19%)	5.19 (5.12%)	127.37 (21.12%)	215.88 (-34.72%)	0.26	2.51
	20	8.23 (1.91%)	5.17 (5.48%)	94.33 (-10.30%)	110.68 (-66.53%)	0.17	3.14
	50	8.27 (1.43%)	5.15 (5.85%)	37.43 (-64.41%)	40.59 (-87.73%)	0.10	4.28
10	1	8.25	4.37	59.65	212.85	1.83	1.83
	2	8.26 (-0.12%)	4.35 (0.46%)	77.69 (30.24%)	286.10 (34.41%)	1.05	2.09
	3	8.27 (-0.24%)	4.35 (0.46%)	90.58 (51.85%)	307.55 (44.49%)	0.79	2.33
	5	8.29 (-0.48%)	4.29 (1.83%)	88.86 (48.97%)	203.29 (-4.49%)	0.50	2.47
	10	8.26 (-0.12%)	4.26 (2.52%)	74.98 (25.70%)	112.85 (-46.98%)	0.30	2.89
	20	8.23 (0.24%)	4.24 (2.97%)	48.71 (-18.34%)	58.18 (-72.67%)	0.19	3.58
	50	8.24 (0.12%)	4.2 (3.89%)	20.18 (-66.17%)	19.21 (-90.97%)	0.11	4.79

Table 3. Table 3 : Small dictation model: Decoding results with the standard algorithm (segment size 1) and our proposed token-wise beam search. In parentheses are the relative improvement % over the standard algorithm. Best throughput and OWER values are in boldface.

N-best	Segment	WER	OWER	Throughput	Throughput	Calls/	Joins/
	Size			CPU (f/s)	GPU (f/s)	Frame	Frame
2	1	4.14	3.71	464.99	807.43	0.94	0.94
	2	4.16 (-0.48%)	3.57 (3.77%)	599.36 (28.90%)	1,289.84 (59.75%)	0.53	1.06
	3	4.12 (0.48%)	3.5 (5.66%)	683.26 (46.94%)	1,474.57 (82.63%)	0.39	1.16
	5	4.14 (-0.00%)	3.49 (5.93%)	484.32 (4.16%)	1,532.11 (89.75%)	0.28	1.38
	10	4.13 (0.24%)	3.45 (7.01%)	457.11 (-1.69%)	573.59 (-28.96%)	0.19	1.85
	20	4.12 (0.48%)	3.42 (7.82%)	156.37 (-66.37%)	222.66 (-72.42%)	0.14	2.74
	50	4.14 (-0.00%)	3.39 (8.63%)	72.45 (-84.42%)	62.20 (-92.30%)	0.11	5.20
5	1	4.09	2.74	218.74	527.52	1.09	1.09
	2	4.08 (0.24%)	2.64 (3.65%)	252.84 (15.59%)	761.86 (44.42%)	0.61	1.21
	3	4.11 (-0.49%)	2.57 (6.20%)	255.33 (16.73%)	848.14 (60.78%)	0.44	1.32
	5	4.07 (0.49%)	2.56 (6.57%)	261.46 (19.53%)	734.32 (39.20%)	0.31	1.55
	10	4.08 (0.24%)	2.51 (8.39%)	177.86 (-18.69%)	248.72 (-52.85%)	0.21	2.06
	20	4.07 (0.49%)	2.48 (9.49%)	77.82 (-64.42%)	93.50 (-82.28%)	0.15	3.01
	50	4.08 (0.24%)	2.44 (10.95%)	19.56 (-91.06%)	29.24 (-94.46%)	0.12	5.53
10	1	4.07	2.15	124.53	367.76	1.17	1.17
	2	4.08 (-0.25%)	2.07 (3.72%)	202.67 (62.75%)	494.83 (34.55%)	0.65	1.30
	3	4.09 (-0.49%)	2.02 (6.05%)	187.53 (50.59%)	487.43 (32.54%)	0.48	1.42
	5	4.09 (-0.49%)	2 (6.98%)	160.05 (28.52%)	283.30 (-22.97%)	0.34	1.68
	10	4.08 (-0.25%)	1.97 (8.37%)	102.65 (-17.57%)	118.40 (-67.81%)	0.23	2.22
	20	4.07 (-0.00%)	1.94 (9.77%)	53.80 (-56.80%)	55.36 (-84.95%)	0.16	3.23
	50	4.08 (-0.25%)	1.91 (11.16%)	13.29 (-89.33%)	14.55 (-96.04%)	0.12	5.78

Table 4. Table 4 : Librispeech model (test-clean): decoding results with the standard algorithm (segment size 1) and our proposed token-wise beam search. In parentheses are the relative improvement % over the standard algorithm. Best throughput and OWER values are in boldface.

N-best	Segment	WER	OWER	Throughput	Throughput	Calls/	Joins/
	Size			CPU (f/s)	GPU (f/s)	Frame	Frame
1	1	3.42	3.42	284.74	877.55	1.13	1.13
	2	3.39 (0.88%)	3.39 (0.88%)	407.89 (43.25%)	1,251.11 (42.57%)	0.64	1.27
	3	3.4 (0.58%)	3.4 (0.58%)	552.30 (93.97%)	1,411.64 (60.86%)	0.47	1.40
	5	3.4 (0.58%)	3.4 (0.58%)	413.66 (45.28%)	1,381.28 (57.40%)	0.34	1.67
	10	3.38 (1.17%)	3.38 (1.17%)	342.11 (20.15%)	1,081.46 (23.24%)	0.24	2.34
	20	3.36 (1.75%)	3.36 (1.75%)	186.54 (-34.49%)	257.02 (-70.71%)	0.19	3.64
	50	3.37 (1.46%)	3.37 (1.46%)	57.70 (-79.74%)	67.73 (-92.28%)	0.16	7.40
2	1	3.32	3.01	182.71	453.58	1.43	1.43
	2	3.33 (-0.30%)	2.86 (4.98%)	199.65 (9.27%)	734.15 (61.86%)	0.76	1.53
	3	3.33 (-0.30%)	2.79 (7.31%)	288.59 (57.95%)	851.07 (87.63%)	0.55	1.65
	5	3.33 (-0.30%)	2.68 (10.96%)	229.88 (25.82%)	886.42 (95.43%)	0.39	1.93
	10	3.3 (0.60%)	2.62 (12.96%)	150.92 (-17.40%)	412.78 (-9.00%)	0.27	2.63
	20	3.31 (0.30%)	2.54 (15.61%)	107.76 (-41.02%)	130.68 (-71.19%)	0.20	3.94
	50	3.3 (0.60%)	2.48 (17.61%)	28.51 (-84.40%)	30.79 (-93.21%)	0.16	7.66
5	1	3.31	2.04	76.81	287.40	1.60	1.60
	2	3.32 (-0.30%)	1.96 (3.92%)	97.17 (26.51%)	429.32 (49.38%)	0.84	1.68
	3	3.31 (-0.00%)	1.93 (5.39%)	121.88 (58.68%)	497.81 (73.21%)	0.60	1.80
	5	3.3 (0.30%)	1.9 (6.86%)	130.72 (70.19%)	390.02 (35.71%)	0.42	2.10
	10	3.29 (0.60%)	1.85 (9.31%)	71.24 (-7.25%)	139.43 (-51.49%)	0.29	2.84
	20	3.3 (0.30%)	1.82 (10.78%)	39.28 (-48.86%)	59.35 (-79.35%)	0.22	4.20
	50	3.3 (0.30%)	1.84 (9.80%)	10.06 (-86.90%)	14.38 (-95.00%)	0.17	8.05
10	1	3.29	1.67	48.88	195.44	1.72	1.72
	2	3.31 (-0.61%)	1.61 (3.59%)	62.04 (26.92%)	281.52 (44.04%)	0.91	1.81
	3	3.29 (-0.00%)	1.59 (4.79%)	81.55 (66.84%)	283.35 (44.98%)	0.65	1.93
	5	3.3 (-0.30%)	1.58 (5.39%)	58.48 (19.64%)	168.04 (-14.02%)	0.45	2.23
	10	3.3 (-0.30%)	1.55 (7.19%)	54.44 (11.37%)	72.46 (-62.92%)	0.30	2.98
	20	3.3 (-0.30%)	1.54 (7.78%)	28.29 (-42.12%)	29.20 (-85.06%)	0.23	4.40
	50	3.29 (-0.00%)	1.52 (8.98%)	5.17 (-89.42%)	7.12 (-96.36%)	0.18	8.34

Equations

$$p(y_1,...,y_U,y_{U+1})=p(y_1,...,y_U)\cdot J(t,U,y_{U+1})$$

$$p(y)=\sum _{t_1=1}^{S}p(y_1,...,y_U(t_1)).$$

$$Bl(U,t_1,t_2)=\{\begin{array}{ll}{\prod }_{t^{\prime }=t_1}^{t_2-1}J(t^{\prime },U,\varphi )& t_1<t_2\\ 1& t_1=t_2\\ 0& t_1>t_2.\end{array}$$

$$\begin{gathered} p(y_1,...,y_U(t_1),y_{U+1}(t_2))= \\ p(y_1,...,y_U(t_1))\cdot Bl(U,t_1,t_2)\cdot J(t_2,U,y_{U+1}). \end{gathered}$$

$$\begin{gathered} d=p(y_1,...,y_U,y_{U+1}(t_2))= \\ \sum _{t_1=1}^{S}p(y_1,...,y_U(t_1),y_{U+1}(t_2)). \end{gathered}$$

$${\delta }^{nb}=p(y_1,...,y_{U+1})=\sum _{t_2=1}^{S}p(y_1,...,y_U,y_{U+1}(t_2)).$$

$${\delta }^{\varphi }=p(y)=\sum _{t_1=1}^{S}p(y_1,...,y_U(t_1))\cdot Bl(U,t_1,S+1).$$

Full text

**Index Terms— ** Speech Recognition, ASR, Decoding, efficiency.

1 Introduction

The Recurrent Neural Network Transducer model (RNN-T) [1, 2] has become a common model of choice for on-device speech recognition over the past few years due to its attractive accuracy to model size tradeoff [3, 4]. Indeed, compared to Connectionist Temporal Classification (CTC) models, RNN-T models normally yield a better word error rate (WER) for a fixed model size [5]. However, CTC models are still largely superior in decoding speed [6], which results from their conditional independence assumption.

During RNN-T decoding with standard algorithms, frames (time steps of the encoder network output) are being iterated over and decoded sequentially. For each frame, the joint network (the joiner) is applied to combine the encoder and prediction networks outputs, before deciding which tokens are added to the N-best hypotheses beam [1, 7, 8]. The process repeats until no new tokens are emitted in this frame, and only then the next frame is decoded. Previous work has shown that even with a single layer joiner, its repeated application is responsible for a significant amount of decoding time and power consumption [9, 10], due to lack of parallelization and repeatedly loading the joiner weight matrix to memory. Note that for models using larger subword units, the joiner is being applied much more often than the prediction network, as the latter is only being applied when a new token is emitted.

While decoding in a strictly monotonic manner along the time axis may be simpler, and mandatory in strict streaming use cases, in practice this is often not required. For non-streaming cases, decoding algorithms may indeed benefit from the available future frames for better accuracy and computational efficiency. In practical streaming cases, streaming is normally done in a segment-by-segment manner, where each segment contains a few frames [11, 12]. Therefore in those scenarios as well, some lookahead is available for the decoding algorithm to benefit from.

In this work, we present a novel beam search decoding algorithm for RNN-T that decodes audio utterances segment by segment. Standard RNN-T decoding algorithms attempt to find the highest scoring decoding paths in a greedy frame-by-frame manner, and the search space is trimmed to contain the highest scoring hypotheses after each frame or token emission. Instead of iterating over frames, our algorithm considers an entire segment of frames simultaneously, and aggregates probabilities of paths leading to identical sequences of token emissions within the entire segment. Our algorithm emits a token after considering all frames in the segment, and the search space is trimmed after each token emission or when the entire segment processing is done. Note that in the extreme case, the segment can be the entire sequence. Since the algorithm does not iterate over frames within the segment anymore, we name this logic token-wise decoding. When using a segment size of one frame, our algorithm is identical to a standard breadth-first RNN-T decoding algorithm [7].

Our decoding approach has two advantages. First, considering the entire segment simultaneously allows us to batch the joint network applications across multiple frames and reduce the total number of invocations of the joint network, which considerably improves the computational efficiency of the inference process. Second, token emission probabilities are potentially spread across a number of frames, which may cause a standard strictly monotonic decoding algorithm to discard a correct hypothesis during search. Our proposed algorithm aggregates emission probabilities across all frames of the decoded segment, which may improve decoding accuracy. This may be viewed as a theoretically motivated improvement to the heuristic search process, that provides a better approximation to finding the most probable token sequence. The algorithm does not require any change to RNN-T model training.

Note that while we reduce the total number of joiner calls, which in general improves decoding speed, each call incurs increased computation, since we are joining the entire segment instead of only one frame. This would not make sense for very long segments, as the total computation may increase dramatically. In the experiments below, we explore multiple segment sizes to find that segments containing about 3-5 frames (after the encoder stride) result in best decoding speed.

Overall, our novel token-wise beam search algorithm for RNN-T generalizes a standard beam search algorithm, and employs a larger lookahead which is normally available in both streaming and non-streaming applications, to improve decoding speed and accuracy. In experiments using both CPUs and GPUs, we find that when using a segment size of 3-5 time frames, we manage to consistently increase the decoding speed by about 20%-96%. In addition, as the segment size increases, decoding accuracy improves, which is demonstrated by up to a 11% improvement in oracle WER and a slight improvements in general WER.

2 Related work

We mention additional related work that was not otherwise mentioned in Section 1. Monotonic RNN-T [7] is another technique capable of reducing the number of joiner invocations. With Monotonic RNN-T, the loss function is altered such that every token emission results in advancing to the next time step, therefore each frame is joined at most once. However, without using complex initialization techniques, monotonic RNN-T normally results in some WER degradation compared to standard RNN-T [13]. Nevertheless, Our proposed algorithm can be easily adjusted to support monotonic RNN-T in order to speed up its decoding even further.

Alignment-length synchronous decoding (ALSD) [10] shows a reduction in joiner invocations and a decoding speedup, however this was compared to an algorithm forcing each hypotheses to a fixed number (at least 4) of expansions per frame. ALSD speedups come from the algorithm’s ability to trim hypotheses early without expanding them, an ability the standard baseline algorithm considered in this work possesses as well. In addition, ALSD allows different hypotheses to be joined with different encoder frames, which cannot be done trivially using a single joiner call, therefore may result in a slowdown compared to other optimized implementations.

Another technique reducing the number of joiner invocations is presented in [9], by using HAT factorization [14] and a threshold on the blank emission probability, above which the joiner will not be invoked. While this method requires replacing standard RNN-T with the HAT variant and finding the appropriate threshold to use, our proposed algorithm can be altered to benefit from this method as well, such that speed gains from both methods are cumulative.

3 Method

3.1 Recurrent Neural Network Transducer

Consider an audio segment (possibly features) denoted $x$, and a sequence of reference tokens (during training) or previously emitted tokens (during inference) $y=(y_{1},...,y_{U})$. The RNN-T model has three main components. The encoder network, processing an audio segment with possible downsampling to length $T$: $h(t)=\mathtt{encoder}(x)$ , the prediction network processing the reference or emitted tokens: $g(u)=\mathtt{predictor}(y)$, and the joint network (the joiner) combining the above into token scores: $j(t,u,k)=\mathtt{joiner}(h,g)$. Here $k$ denotes the token from a vocabulary $V\cup\{\phi\}$ where $\phi$ is the blank symbol.

During decoding with an RNN-T model, the search process aims at finding the most probable output sequence: $y^{*}=argmax_{y}\,p(y|x)$. Solving for the latter is intractable in practice, therefore beam search algorithms are normally used. Common versions are variants of the original algorithm [1], such as [7, 8, 10]. In this work, we refer to the breadth-first beam search algorithm from [7] as the standard decoding algorithm. This standard algorithm was used in many works including [15, 16, 12, 17, 18].

The standard algorithm decodes along the time axis of the audio. At each iteration, given $N$ hypotheses in the beam, the joiner computes token emission probabilities for the current frame, including blank emission. Existing hypotheses are then expanded by either a blank or a non-blank symbol:

[TABLE]

where $J$ is the joiner output $j$ after softmax normalization, and $y_{U+1}\in V\cup\{\phi\}$ here. The most likely $N$ new hypotheses replace the previous ones in the beam. The probability of different alignments corresponding to the same token sequence are summed. Since RNN-T allows multiple token emissions in a single time-step, the next iteration moves to the next frame only after all hypotheses in the beam end with a blank symbol emission. As a result, the joiner is invoked at least once per frame, and at least once more if some non-blank tokens are emitted in any of the $N$ hypotheses in the beam during this frame.

3.2 Token-Wise Beam Search

As motivated above, our goal is to speed up decoding by reducing the total number of joiner invocations. Decoding is often done in an offline manner for an entire sequence, or in a non-strict streaming setting in a segment-by-segment manner, with each segment containing multiple encoder output frames. Therefore, we design an algorithm that decodes a number of frames simultaneously, allowing batching joiner invocations across frames and potentially improving the search accuracy.

The standard algorithm iterates over frames, and for each frame finds the highest scoring hypothesis expansions. The search space is normally trimmed to contain the N-best hypotheses after each token emission and before the next frame is processed. Instead, we consider the entire segment of frames simultaneously, and aggregate probabilities of paths leading to identical sequences of token emissions within the entire segment. Note that in this case, the emission of the token is not associated anymore with any specific frame in the segment, but it results in a distribution over the segment frames that describes where the token was emitted. This distribution is used in the next token emission iteration, to continue aggregating the path probabilities across a segment correctly and to make sure the next token cannot be emitted before the previous one.

We describe mathematically how to aggregate emission probabilities across a sequence of frames of length $S$. While the mathematics is a bit more complex than for the standard algorithms, it only amounts to summing the probabilities of the correct paths within a segment that lead to a given sequence of tokens. Assume a prefix of non-blank tokens $y=(y_{1},...,y_{U})$ with probability $p(y)$. For each frame $t_{1}$ denote the associated probability $p(y_{1},...,y_{U}(t_{1}))$ of the sequence $y$ where the last token $y_{U}$ was emitted in frame $t_{1}$, such that:

[TABLE]

Define the probability of emitting blank from frame $t_{1}$ to frame $t_{2}$ as:

[TABLE]

The probability to emit a new token $y_{U+1}$ at frame $t_{2}$, given that the previous token was emitted in an earlier frame $t_{1}$, is the probability of emitting blanks from $t_{1}$ to $t_{2}$ and emit $y_{U+1}$ at $t_{2}$:

[TABLE]

The probability to emit a new token $y_{U+1}$ at time $t_{2}$ is then factored across the different $t_{1}$ locations:

[TABLE]

Finally, the probability of expanding $y$ with a the new non-blank token $y_{U+1}$ across the segment is then factored across the different $t_{2}$ locations:

[TABLE]

For blank expansions, the token sequence does not change, and its probability is updated using blank emission probabilities for the rest of the segment:

[TABLE]

Equations 3-7 are used to compute the aggregated token emission probabilities across the segment. When starting to decode a segment, we assume the distribution of $p(y_{1},...,y_{U}(t_{1}))$ is concentrated in the first frame of the segment ($t_{1}=1)$. In consecutive steps, Eq. 5 from the previous step is used as the distribution over last token emission frames. The rest of the algorithm is identical to the standard algorithm, including summing scores of hypotheses that correspond to the same token sequence. Note that when $S=1$, the sequence expansion probabilities amount to precisely the way those are computed in the standard algorithm time-wise algorithm in Eq. 1, therefore the proposed algorithm is a natural generalization of the standard algorithm.

The full algorithm is given at Algorithm 1, with all parts other than Equations 3-7 being fairly standard. On a high level, at every iteration, a segment is processed, and all existing hypotheses start in group A. Token scores are computed using the above equations, are top scoring tokens are added to expand the hypotheses. When a blank token is added, the hypothesis is moved to group B and is considered done for the current segment. When no more hypotheses remain in group A, we move to the next segment.

Note that for simplicity, the algorithm assumes the encoder output was computed beforehand. In streaming applications, one may want to compute the encoder output in a segment-by-segment manner as well, and integrate that into Algorithm 1. The segment size used for encoder computation and decoding are not necessarily constraint to be equal. In initial experiments, we included a version of the algorithm that limits the maximum number of tokens to emit in a segment, similar to the N-step constrained beam search from [8]. However, we found that for all segment sizes, tuning this hyperparameter does not lead to any compute savings without a considerable degradation in WER, therefore we omit this functionality from the algorithm.

We briefly explain some of the simple helper functions used in Algorithm 1. The function $\mathtt{InitPredictor}$ returns the initial state of the predictor, which is initialized the same way as a weight matrix. $\mathtt{Length}$/$\mathtt{Append}$ are the standard list operations. $\mathtt{ChooseNBest}$ returns the $N$ hypotheses with highest scores out of a list of hypotheses. $\mathtt{AddAndMerge}$ adds a hypothesis to a list of hypotheses, and in case a hypothesis with the same tokens already exists in the list, the two are merged by summing their scores. $\mathtt{ChooseNthScore}$ returns the $N$-th highest score of a hypotheses list. $\mathtt{ChooseNBestExpansions}$ takes the non-blank expansion scores for all hypotheses and returns the top $N$ expansions by score as pairs comprising of a hypothesis index and an expansion token. $\mathtt{UpdatePredictorOutput}$ runs the RNN-T predictor with the updated hypotheses tokens, and updates their predictor output member.

4 Experiments

4.1 RNN-T Models and Data

Three different standard RNN-T models are evaluated. The first is trained on Librispeech data [19], where the encoder network contains 20 Emformer layers [11] and performs a total stride of 4, the prediction network contains 3 LSTM layers, and the joiner is a ReLU layer followed by a single fully connected layer projecting the representation to the vocabulary dimension. For this model, 500 subword units are used [20]. This model has in total of 78M parameters. The second and third models are trained on large in-house dataset containing 1.5M hours speech data. Our in-house training set combines two sources. The first consists of English video data publicly shared by Facebook users; all videos are completely de-identified. The second contains de-identified English data with no user-identifiable information in the voice assistant domain. All utterances are morphed when the speakers are de-identified. Note that the data is not morphed during training. The second model contains 28 Emformer layers in the encoder network with a total stride of 4, and 2 LSTM layers in the prediction network. The third model contains 13 Emformer layers with a total stride of 6, and a single LSTM layer in the prediction network. The joint network is identical to the ones used in the Librispeech model. The total number of parameters in the second and third models are 104M and 27M respectively. We evaluate the second model on a voice assistant test set, and the third model on a voice dictation test set.

4.2 Results

We evaluate the token-wise beam search algorithm using different segment sizes to measure accuracy and decoding speed. When using a segment size of one, our algorithm is identical to the standard algorithm, as also verified in initial experiments. Therefore all results are reported using the same implementation, to avoid any noise during performance measurements. Results on three datasets appear in Tables 1, 2 and 3. The results in the appendix follow a similar trend. The CPU / GPU results in the above mentioned tables were obtained using a single core CPU / single GPU.

The first observation from the results is that using the token-wise beam search with optimized segment size of 2-5 frames consistently improves throughput over the standard algorithm (segment size of 1). Throughput is measured as number frames (of the encoder output) decoded per second. The best segment size results in 20%-96% throughput increase over the standard algorithm. The last two columns provide further insight regarding the speed gains. Calls / Frame is the average number of times the joint network is invoked per frame, which decreases consistently as the segment size increases. On the other hand, each joiner call involves a larger number of frames as the segment size increases. The Joins / Frame column measures the total joiner computation as the average number each frame was in the joiner input. Overall, total compute increases with the segment size, but since the number of joiner calls decreases at the same time and each call incurs an extra cost, segment sizes of 3-5 result in a good tradeoff with considerable overall speedups.

The second observation is that token-wise beam search benefits from aggregating emission probabilities across a segment, as seen in improved Oracle WER (OWER) as the segment size increases. Oracle WER measures the maximum WER in the $N$ best hypotheses returned by the search algorithm. Improvements in OWER are up to 11% relative for a segment size of 50 frames. As the entire set of $N$ best hypotheses are often processed by downstream applications such as natural language understanding models [21, 22, 23, 24], this improvement may be useful in those situations.

5 Conclusion

We proposed a token-wise beam search algorithm for RNN-T models that does not require any changes to the trained model, and can be applied in any offline or standard non-strict streaming decoding setting. Our algorithm aggregates emission probabilities over segments of frames, thus reducing the number of joiner invocations, which result in consistent 20%-96% speedups, and improves search accuracy as seen in up to 11% oracle WER improvement. In future work, we plan to adjust this algorithm to support monotonic RNN-T [7] and blank thresholding [9] to further improve decoding speed.

Appendix A Additional results

See pages below for additional result tables.