// doc/online_decoding.dox
// Copyright 2014 Johns Hopkins University (author: Daniel Povey)
// See ../../COPYING for clarification regarding multiple authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
// THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
// WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
// MERCHANTABLITY OR NON-INFRINGEMENT.
// See the Apache 2 License for the specific language governing permissions and
// limitations under the License.
namespace kaldi {
/**
\page online_decoding Online decoding in Kaldi
This page documents the capabilities for "online decoding" in Kaldi. By
"online decoding" we mean decoding where the features are coming in in real
time, and you don't want to wait until all the audio is captured before
starting the online decoding. (We're not using the phrase "real-time decoding"
because "real-time decoding" can also be used to mean decoding whose speed is
not slower than real time, even if it is applied in batch mode).
Note: see \subpage online_programs for some now-deprecated online recognizers.
The approach that we took with Kaldi was to focus for the first few years
on off-line recognition, in order to reach state of the art performance
as quickly as possible. Now we are making more of an effort to support
online decoding.
There are two online-decoding setups: the "old" online-decoding setup, in the
subdirectories online/ and onlinebin/, and the "new" decoding setup,
in online2/ and online2bin/. The "old" online-decoding setup is now
deprecated, and may eventually be removed from the trunk (but remain in
^/branches/complete).
There is some documentation for the older setup \ref online_programs "here",
but we recommend to read this page first.
\section online_decoding_scope Scope of online decoding in Kaldi
In Kaldi we aim to provide facilities for online decoding as a library.
That is, we aim to provide the functionality for online decoding but
not necessarily command-line tools for it. The reason is, different
people's requirements will be very different depending on how the data is
captured and transmitted. In the "old" online-decoding setup we provided facilities
for transferring data over UDP and the like, but in the "new" online-decoding
setup our only aim is to demonstrate the internal code, and for now
we don't provide any example programs that you could hook up to actual
real-time audio capture; you would have to do that yourself.
We have decoding programs for GMM-based models (see next section) and for
neural net models (see section \ref online_decoding_nnet2).
\section GMM-based online decoding
The program online2-wav-gmm-latgen-faster.cc is currently the primary example program
for the GMM-based online-decoding setup. It reads in whole wave files but internally it processes them chunk by chunk with
no dependency on the future. In the example script egs/rm/s5/local/online/run_gmm.sh
you can see an example script for how you build models suitable for this program
to use, and evaluate it. The main purpose of program is to apply the GMM-based online-decoding
procedure within a typical batch-processing framework, so that you can easily
evaluate word error rates. We plan to add similar programs for SGMMs and DNNs.
In order to actually do online decoding, you would have to modify this program.
We should note (and this is obvious to speech recognition people but not to outsiders)
that the audio sample rate needs to exactly match what you used in training (and
oversampling won't work but subsampling will).
\section online_decoding_decoders Decoders versus decoding programs
In Kaldi, when we use the term "decoder" we don't generally mean the entire decoding
program. We mean the inner decoder object, generally of the type LatticeFasterDecoder.
This object takes the decoding graph (as an FST), and the decodable object
(see \ref decodable_interface). All the decoders naturally support online decoding; it
is the code in the decoding program (but outside of the decoder) that needs to
change. We should note, though, a difference in how you need to invoke the decoder
for online decoding.
- In the old online-decoding setup (in online/), if "decoder" is some decoder
(e.g. of type LatticeFasterDecoder) and "decodable" is a decodable object of
a suitable type, you would call decoder.Decode(&decodable),
and this call would block until the input was finished (because the decoder
calls decodable.IsLastFrame(), which blocks).
- In the new online-decoding setup (in online2/), you would instead call
decoder.InitDecoding(), and then each time you get more feature data, you
would call decoder.AdvanceDecoding(). For offline use, you can still call
Decode().
We should mention here that in the old online setup, there is a decoder called
OnlineFasterDecoder. Do not assume from the name of this that it is the only
decoder to support online decoding. The special thing about the OnlineFasterDecoder
is that it has the ability to work out which words are going to be "inevitably"
decoded regardless of what audio data comes in in future, so you can output those
words. This is useful in an online-transcription context, and if there seems to
be a demand for this, we may move that decoder from online/ into the decoder/
directory and make it compatible with the new online setup.
\section online_decoding_feature Feature extraction in online decoding
Most of the complexity in online decoding relates to feature extraction
and adaptation.
In online-feature.h we provide classes that provide various components
of feature extraction, all inheriting from class OnlineFeatureInterface.
OnlineFeatureInterface is a base class for online feature extraction.
The interface specifies how the object provides the features to the caller
(OnlineFeatureInterface::GetFrame()) and how it says how many frames
are ready (OnlineFeatureInterface::NumFramesReady()), but does not
say how it obtains those features. That is up to the child class.
In online-feature.h we define classes OnlineMfcc and OnlinePlp which
are the lowest-level features. They have a member function
OnlineMfccOrPlp::AcceptWaveform(), which the user should call when
data is captured. All the other online feature types in online-feature.h
are "derived" features, so they take an object of OnlineFeatureInterface
in their constructor and get their input features through a stored pointer
to that object.
The only part of the online feature extraction code in online-feature.h
that is non-trivial is the cepstral mean and variance normalization (CMVN)
(and note that the fMLLR, or linear transform, estimation is not trivial but
the complexity lies elsewhere). We describe the CMVN below.
\section online_decoding_cmvn Cepstral mean and variance normalization in online decoding
Cepstral mean normalization is a normalization method in which
the mean of the data (typically of the raw MFCC features) is subtracted.
"Cepstral" simply refers to the normal feature type; the first C in MFCC means
"Cepstral".. the cepstrum is the inverse fourier transform of the log spectrum,
although it's actually the cosine transform that is used.
Anyway, in cepstral variance normalization, each feature dimension is scaled
so that its variance is one. In all the current scripts, we turn cepstral
variance normalization off and only use cepstral mean normalization, but the
same code handles both. In the discussion below, for brevity we will refer only to cepstral
mean normalization.
In the Kaldi scripts, cepstral mean and variance normalization (CMVN) is
generally done on a per-speaker basis. Obviously in an online-decoding
context, this is impossible to do because it is "non-causal" (the current
feature depends on future features).
The basic solution we use is to do "moving-window" cepstral mean
normalization. We accumulate the mean over a moving window of, by default, 6
seconds (see the "--cmn-window" option to programs in online2bin/, which
defaults to 600). The options class for this computation, OnlineCmvnOptions,
also has extra configuration variables, speaker-frames (default: 600), and
global-frames (default: 200). These specify how we make use of prior
information from the same speaker, or a global average of the cepstra, to
improve the estimate for the first few seconds of each utterance.
The program \ref apply-cmvn-online.cc "apply-cmvn-online" can apply this normalization
as part of a training pipeline so that we can can train on matched features.
\subsection online_decoding_cmvn_freeze Freezing the state of CMN
The OnlineCmvn class has functions \ref OnlineCmvn::GetState "GetState" and
\ref OnlineCmvn::SetState "SetState" that make it possible to keep track of
the state of the CMVN computation between speakers. It also has a function
\ref OnlineCmvn::Freeze() "Freeze()". This function causes it to freeze the
state of the cepstral mean normalization at a particular value, so that after
calling \ref OnlineCmvn::Freeze() "Freeze()", any calls to \ref
OnlineCmvn::GetFrame() "GetFrame()", even for earlier times, will apply the
mean offset that we were using when the user called \ref OnlineCmvn::Freeze()
"Freeze()". This frozen state will also be propagated to future utterances of
the same speaker via the \ref OnlineCmvn::GetState "GetState" and \ref
OnlineCmvn::SetState "SetState" function calls. The reason we do this is that
we don't believe it makes sense to do speaker adaptation with fMLLR on top
of a constantly varying CMN offset. So when we start estimating fMLLR
(see below), we freeze the CMN state and leave it fixed in future. The
value of CMN at the time we freeze it is not especially critical because fMLLR subsumes
CMN. The reason we freeze the CMN state to a particular value rather than just
skip over the CMN when we start estimating fMLLR, is that we are actually
using a method called basis-fMLLR (again, see below) where we incrementally
estimate the parameters, and it is not completely invariant to offsets.
\section online_decoding_adaptation Adaptation in online decoding
The most standard adaptation method used for speech recognition is
feature-space Maximum Likelihood Linear Regression (fMLLR), also known in the
literature as Constrained MLLR (CMLLR), but we use the term fMLLR in the Kaldi
code and documentation. fMLLR consists of an affine (linear + offset) transform
of the features; the number of parameters is d * (d+1), where d is the
final feature dimension (typically 40). In the online decoding program
a basis method to incrementally estimate an increasing number of
transform parameters as we decode more data. The top-level logic for this at the
decoder level is mostly implemented in class SingleUtteranceGmmDecoder.
The fMLLR estimation is done not continuously but periodically, since it involvesa
computing lattice posteriors and this can't very easily be done in a continuous
manner. Configuration variables in class OnlineGmmDecodingAdaptationPolicyConfig
determine when we re-estimate fMLLR. The default currently is, during the first
utterance, to estimate it after 2 seconds, and thereafter at times in a geometrically
increasing ratio with constant 1.5 (so at 2 seconds, 3 seconds, 4.5 seconds...).
For later utterances we estimate it after 5 seconds, 10 seconds, 20 seconds and so on.
For all utterances we estimate it at the end of the utterance.
Note that the CMN adaptation state is frozen, as mentioned above, the first time
we estimate fMLLR for a speaker, which by default will be two seconds into the
first utterance.
\section online_decoding_models Use of multiple models in GMM-based online decoding
In the online decoding decode for GMMs in online-gmm-decoding.h, up to three
models can be supplied. These are held in class OnlineGmmDecodingModels, which
takes care of the logic necessary to decide which model to use for different purposes
if fewer models are supplied. The three models are:
- A speaker-independent model, trained with online-mode CMVN from
\ref apply-cmvn-onlin.cc apply-cmvn-online
- A speaker adapted model, trained with fMLLR
- A discriminatively trained version of the speaker adapted model
It is our practice to use a Maximum Likelihood estimated model to estimate
adaptation parameters, as this is more consistent with the Maximum framework
than using a discriminatively trained model, although this probably makes little
difference and you would lose little (and save some memory) by using the discriminatively
trained model for this purpose.
\section online_decoding_nnet2 Neural net based online decoding with iVectors
Our best online-decoding setup, which we recommend should be used, is the neural
net based setup. The adaptation philosphy is to give the neural net un-adapted
and non-mean-normalized features (MFCCs, in our example recipes), and also to give
it an iVector. An iVector is a vector of dimension several hundred (one or two hundred,
in this particular context) which represents the speaker properties. For more information
on this the reader can look at the speaker identification literature. Our idea is that
the iVector gives the neural net as much as it needs to know about the speaker properties.
This has proved quite useful. The iVector is estimated in a left-to-right way, meaning
that at a certain time t, it sees input from time zero to t. It also sees information
from previous utterances of the current speaker, if available. The iVector estimation is
Maximum Likelihood, involving Gaussian Mixture Models.
If pitch is used (e.g. for tonal languages), we don't include it in the features used for
iVector estimation, in order to simplify things; we just include it in the features given
to the neural network. We don't yet have example scripts for the online-neural-net decoding
for tonal languages; it is still being debugged.
The neural nets in our example scripts for online decoding are p-norm neural networks, typically
trained in parallel on several GPUs. We have these example scripts for several different
example setups, e.g. in egs/rm/s5, egs/wsj/s5, egs/swbd/s5b, and egs/fisher_english/s5.
The top-level example script is always called local/online/run_nnet2.sh. In the case of the
Resource Management recipe there is also a script local/online/run_nnet2_wsj.sh. This demonstrates
how to take a larger neural net trained on out-of-domain speech with the same sampling rate (in
this example, WSJ), and retrain it on in-domain data. In this way we obtained our best-ever
results on RM.
We are currently working on example scripts for discriminative training for this setup.
\subsection online_decoding_nnet2_example Example for using already-built online-nnet2 models
In this section we will explain how to download already-build online-nnet2 models from www.kaldi-asr.org
and evaluate them on your own data.
The reader can download the models and other relating files from
http://kaldi-asr.org/downloads/build/2/sandbox/online/egs/fisher_english/s5 ,
which are built using the fisher_english recipe. To use the online-nnet2 models, the reader
only needs to download two directories: exp/tri5a/graph and exp/nnet2_online/nnet_a_gpu_online. Use the
following commands to download the archives and extract them:
\verbatim
wget http://kaldi-asr.org/downloads/build/5/trunk/egs/fisher_english/s5/exp/nnet2_online/nnet_a_gpu_online/archive.tar.gz -O nnet_a_gpu_online.tar.gz
wget http://kaldi-asr.org/downloads/build/2/sandbox/online/egs/fisher_english/s5/exp/tri5a/graph/archive.tar.gz -O graph.tar.gz
mkdir -p nnet_a_gpu_online graph
tar zxvf nnet_a_gpu_online.tar.gz -C nnet_a_gpu_online
tar zxvf graph.tar.gz -C graph
\endverbatim
Here the archives are extracted to the local directory. We need to modify pathnames in the
config files, which we can do as follows:
\verbatim
for x in nnet_a_gpu_online/conf/*conf; do
cp $x $x.orig
sed s:/export/a09/dpovey/kaldi-clean/egs/fisher_english/s5/exp/nnet2_online/:$(pwd)/: < $x.orig > $x
done
\endverbatim
Next, choose a single wav file to decode. The reader can download a sample file by typing
\verbatim
wget http://www.signalogic.com/melp/EngSamples/Orig/ENG_M.wav
\endverbatim
This is a 8kHz-sampled wav file that we found online (unfortunately it is UK
English, so the accuracy is not very good). It can be decoded with the following command:
\verbatim
~/kaldi-online/src/online2bin/online2-wav-nnet2-latgen-faster --do-endpointing=false \
--online=false \
--config=nnet_a_gpu_online/conf/online_nnet2_decoding.conf \
--max-active=7000 --beam=15.0 --lattice-beam=6.0 \
--acoustic-scale=0.1 --word-symbol-table=graph/words.txt \
nnet_a_gpu_online/final.mdl graph/HCLG.fst "ark:echo utterance-id1 utterance-id1|" "scp:echo utterance-id1 ENG_M.wav|" \
ark:/dev/null
\endverbatim
We added the --online=false option because it tends to slightly improve results.
You can see the result in the logging output (although there are other ways to retrieve this).
For us, the logging output was as follows:
\verbatim
/home/dpovey/kaldi-online/src/online2bin/online2-wav-nnet2-latgen-faster --do-endpointing=false --online=false --config=nnet_a_gpu_online/conf/online_nnet2_decoding.conf --max-active=7000 --beam=15.0 --lattice-beam=6.0 --acoustic-scale=0.1 --word-symbol-table=graph/words.txt nnet_a_gpu_online/smbr_epoch2.mdl graph/HCLG.fst 'ark:echo utterance-id1 utterance-id1|' 'scp:echo utterance-id1 ENG_M.wav|' ark:/dev/null
LOG (online2-wav-nnet2-latgen-faster:ComputeDerivedVars():ivector-extractor.cc:180) Computing derived variables for iVector extractor
LOG (online2-wav-nnet2-latgen-faster:ComputeDerivedVars():ivector-extractor.cc:201) Done.
utterance-id1 tons of who was on the way for races two miles and then in nineteen ninety to buy sodas sale the rate them all these to commemorate columbus is drawn into the new world five hundred years ago on the one to the moon is to promote the use of so the sales in space exploration
LOG (online2-wav-nnet2-latgen-faster:main():online2-wav-nnet2-latgen-faster.cc:253) Decoded utterance utterance-id1
LOG (online2-wav-nnet2-latgen-faster:Print():online-timing.cc:51) Timing stats: real-time factor for offline decoding was 1.62102 = 26.7482 seconds / 16.5009 seconds.
LOG (online2-wav-nnet2-latgen-faster:main():online2-wav-nnet2-latgen-faster.cc:259) Decoded 1 utterances, 0 with errors.
LOG (online2-wav-nnet2-latgen-faster:main():online2-wav-nnet2-latgen-faster.cc:261) Overall likelihood per frame was 0.230575 per frame over 1648 frames.
\endverbatim
Note that for mismatched data, sometimes the iVector estimation can get confused and lead to bad results.
Something that we have found useful is to weight down the silence in the iVector estimation.
To do this you can set e.g. --ivector-silence-weighting.silence-weight=0.001; you need to set the silence
phones as appropriate, e.g. --ivector-silence-weighting.silence-phones=1:2:3:4
(this should be a list of silence or noise phones in your phones.txt; you can experiment with
which ones to include).
\subsection online_decoding_nnet2_lm Example for using your own language model with existing online-nnet2 models
Oftentimes users will have to use their own language model to improve the
recognition accuracy. In this section we will explain how to build a language
model with SRILM, and how to incorporate this language model to the existing
online-nnet2 models.
We first have to build an ARPA format language model with SRILM. Note that SRILM
comes with a lot of training options, and we assume it's the user's
responsibility to figure out what is the best setting for their own application.
Suppose "train.txt" is our language model training corpus (e.g., training
data transcriptions), and "wordlist" is our vocabulary. Here we assume the
language model vocabulary is the same as the recognizer's vocabulary, i.e., it
only contains the words from data/lang/words.txt, except the epsilon symbol
"" and disambiguation symbol "#0". We will explain how we can use a
different vocabulary in the next section. We can build a 3gram Kneser-Ney
language model using the following SRILM command
\verbatim
ngram-count -text train.txt -order 3 -limit-vocab -vocab wordlist -unk \
-map-unk "" -kndiscount -interpolate -lm srilm.o3g.kn.gz
\endverbatim
Now that we have the ARPA format language model trained, we have to compile it
into WFST format. Let's first define the following variables
\verbatim
dict_dir=data/local/dict # The dict directory provided by the online-nnet2 models
lm=srilm.o3g.kn.gz # ARPA format LM you just built.
lang=data/lang # Old lang directory provided by the online-nnet2 models
lang_own=data/lang_own # New lang directory we are going to create, which contains the new language model
\endverbatim
Given the above variables, we can compile an ARPA format language model into
WFST format using the following commands
\verbatim
utils/format_lm.sh $lang $lm $dict_dir/lexicon.txt $lang_own
\endverbatim
Now, we can compile the decoding graph with the new language model, using the
following command
\verbatim
graph_own_dir=$model_dir/graph_own
utils/mkgraph.sh $lang_own $model_dir $graph_own_dir || exit 1;
\endverbatim
where $model_dir is the model directory which contains the model "final.mdl"
and the tree "tree". At this point, we can use $graph_own_dir/HCLG.fst to
replace the old HCLG.fst, which uses the language model we just built.
\subsection online_decoding_nnet2_vocab Example for using a different vocabulary with existing online-nnet2 models
For most applications users will also have to change the recognizer's existing
vocabulary, for example, adding out-of-vocabulary words such as person names
to the existing vocabulary. In this section we will explain how this can be
done.
We first have to create a new pronunciation lexicon, typically by adding more
words to the recognizer's existing pronunciation lexicon. The recognizer's
lexicon that we are going to modify is usually located at the $dict_dir/lexicon.txt,
where $dict_dir is the recognizer's dictionary directory, and is usually
data/local/dict. The new lexicon can be created manually by adding new lexical
entries to $dict_dir/lexicon.txt. If we do not have pronunciations for the new
words, we can use grapheme-to-phoneme (G2P) conversion to generate pronunciations
automatically. The commonly used G2P tools are Sequitur and Phonetisaurus, the
later is usually much faster.
The second step is to create a dictionary directory for our new lexicon, which
contains the required files, for example, lexicon.txt, lexiconp.txt, etc.
Most likely if we don't change the lexicon's phone set, the old files such as
extra_questions.txt, nonsilence_phones.txt, optional_silence.txt,
silence_phones.txt can be re-used. For details of how to create those files, we
suggest the users follow the existing Kaldi scripts, for example this one:
egs/wsj/s5/local/wsj_prepare_dict.sh. The format of the dictionary directory is
described \ref data_prep_lang_creating "here".
Now we can create a new lang directory with the updated lexicon. Suppose
$lang is the recognizer's old lang directory, $lang_own is the new lang
directory that we are going to create, $dict_own is the dictionary directory we
just created, and "" is the word symbol that represents
out-of-vocabulary words in the lexicon, we can generate the new lang directory
with the updated lexicon using the following command
\verbatim
lang_own_tmp=data/local/lang_own_tmp/ # Temporary directory.
utils/prepare_lang.sh \
--phone-symbol-table $lang/phones.txt \
$dict_own "" $lang_own_tmp $lang_own
\endverbatim
Make usre you use the option "--phone-symbol-table", which makes sure that
phones in your new lexicon will be compatible with the recognizer.
The last step is of course to update the decoding graph, using the following
command
\verbatim
graph_own_dir=$model_dir/graph_own
utils/mkgraph.sh $lang_own $model_dir $graph_own_dir || exit 1;
\endverbatim
where $model_dir is the model directory which contains the model "final.mdl"
and the tree "tree". We now can use $graph_own_dir/HCLG.fst to replace the old
HCLG.fst.
\section online_decoding_nnet3 Online decoding with nnet3 models
Online decoding with nnet3 models is basically the same as with nnet2
models as described in \ref online_decoding_nnet2. However, there are
some limitations as to the model type you can use. In Kaldi 5.0 and
earlier, online nnet3 decoding does not support recurrent models.
In Kaldi 5.1 and later, online nnet3 decoding supports "forward"
recurrent models such as LSTMs, but not bidirectional ones like BLSTMs.
In addition, online nnet3 decoding with recurrent
models may not give optimal results unless
you use "Kaldi-5.1-style" configuration, including the "decay-time"
option and specifying --extra-left-context-initial 0; see
\ref dnn3_scripts_context for more discussions of these issues.
Many of the issues in online nnet3 decoding are the same as in nnet2
decoding and the command lines are quite similar. For online nnet3
decoding with Kaldi 5.1 and later, the best example script for online
decoding including model training is, at the
time of writing, egs/tedlium/s5_r2/local/chain/tuning/run_tdnn_lstm_1e.sh
(at the time of writing this is only available in the 'shortcut' branch,
as Kaldi 5.1 has not yet been merged to master);
and downloadable models that can be used with online nnet3 decoding, please
see http://kaldi-asr.org/models.html (the first model there, the ASPIRE model,
includes instructions in a README file).
\subsection online_decoding_nnet3_tcp TCP server for nnet3 online decoding
The program to run the TCP sever is online2-tcp-nnet3-decode-faster located in the
~/src/online2bin folder. The usage is as follows:
\verbatim
online2-tcp-nnet3-decode-faster
\endverbatim
For example:
\verbatim
online2-tcp-nnet3-decode-faster model/final.mdl graph/HCLG.fst graph/words.txt
\endverbatim
The word symbol table is mandatory (unlike other nnet3 online decoding programs) because
the server outputs word strings. Endpointing is mandatory to make the operation of the
program reasonable. Other, non-standard options include:
- port-num - the port the server listens on (by default 5050)
- samp-freq - sampling frequency of audio (usually 8000 for telephony and 16000 for other uses)
- chunk-length - length of signal being processed by decoder at each step
- output-period - how often we check for changes in the decoding (ie. output refresh rate, default 1s)
- num-threads-startup - number of threads used when initializing iVector extractor
- read-timeout - it the program doesn't receive data during this timeout, the server terminates the connection.
Use -1 to disable this feature.
The TCP protocol simply takes RAW signal on input (16-bit signed integer
encoding at chosen sampling frequency) and outputs simple text using the following
logic:
- each refresh period (output-freq argument) the current state of decoding is output
- each line is terminated by '\r'
- once an utterance boundary is detected due to endpointing a '\n' char is output
Each output string (delimited by '\r') should be treated as uncertain and can change
entirely until the utterance delimiter ('\n') is sent. The delimiter chars are chosen
specifically in order to make the output look neat in the terminal. It is possible to
use it with other interfaces and a web demo (HTML/JS AudioAPI+WebSockets) exists.
To run the program from the terminal you can use one of the following commands. First,
make sure the server is running and accepting connections. Using the Aspire models, the
command should look like this:
\verbatim
online2-tcp-nnet3-decode-faster --samp-freq=8000 --frames-per-chunk=20 --extra-left-context-initial=0
--frame-subsampling-factor=3 --config=model/conf/online.conf --min-active=200 --max-active=7000
--beam=15.0 --lattice-beam=6.0 --acoustic-scale=1.0 --port-num=5050 model/final.mdl graph/HCLG.fst graph/words.txt
\endverbatim
Note in order to make the communication as simple as possible, the server has to accept
any data on input and cannot figure out when the stream is over. It will therefore not
be able to terminate the connection and it is the client's resposibility to disconnect
when it is ready to do so. As a fallback for certain situations, the read-timeout option
was added, which will automatically disconnect if a chosen amount of seconds has passed.
Keep in mind, that this is not an ideal solution and it's a better idea to design your
client to properly disconnect the connection when neccessary.
For testing purposes, we will use the netcat program. We will also use sox to reeoncode the
files properly from any source. Netcat has an issue that, similarly to what was stated above
about the server, it cannot always interpret the data and usually it won't automatically
disconnect the TCP connection. To get around this, we will use the '-N' switch, which kills
the connection once streaming of the file is complete, but this can have a small sideffect of
not reading the whole output from the Kaldi server if the discconect comes too fast. Just
keep this in mind if you intend to implement any of these programs into a production environment.
To send a WAV file into the server, it first needs to be decoded into raw audio, then it can be
sent to the socket:
\verbatim
sox audio.wav -t raw -c 1 -b 16 -r 8k -e signed-integer - | nc -N localhost 5050
\endverbatim
It is possible to play audio (almost) simultaneously as decoding. It may require installing the
'pv' program (used to throttle the signal into Kaldi at the same speed as the playback):
\verbatim
sox audio.wav -t raw -c 1 -b 16 -r 8k -e signed-integer - | \
tee >(play -t raw -r 8k -e signed-integer -b 16 -c 1 -q -) | \
pv -L 16000 -q | nc -N localhost 5050
\endverbatim
Finally, it is possible to send audio from the microphone directly into the server:
\verbatim
rec -r 8k -e signed-integer -c 1 -b 16 -t raw -q - | nc -N localhost 5050
\endverbatim
*/
}