Merge branch 'master' of github.com:alphacep/vosk-api

Cleaning up and completing go bindings

go/COPYING

@@ -0,0 +1,176 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. this License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

go/doc.go

@@ -0,0 +1,7 @@
+// Go bindings for Vosk speech recognition toolkit. Vosk is an offline
+// open source speech to text API for Android, iOS, Raspberry Pi and
+// servers. It enables speech recognition models for 18 languages and
+// dialects - English, Indian English, German, French, Spanish, Portuguese,
+// Chinese, Russian, Turkish, Vietnamese, Italian, Dutch, Catalan, Arabic,
+// Greek, Farsi, Filipino, Ukrainian.
+package vosk

go/example/doc.go

@@ -0,0 +1,2 @@
+// Example package for Vosk Go bindings.
+package test_simple

go/example/main.go

@@ -1,36 +0,0 @@
-package main
-
-import (
-    "flag"
-    "os"
-    ".."
-)
-
-func main() {
-    var filename string
-    flag.StringVar(&filename, "f", "", "file to transcribe")
-    flag.Parse()
-    model, err := vosk.NewModel("model")
-    rec, err := vosk.NewRecognizer(model)
-
-    file, err := os.Open(filename)
-    if err != nil {
-        panic(err)
-    }
-    defer file.Close()
-
-    fileinfo, err := file.Stat()
-    if err != nil {
-        panic(err)
-    }
-
-    filesize := fileinfo.Size()
-    buffer := make([]byte, filesize)
-
-    _, err = file.Read(buffer)
-    if err != nil {
-        panic(err)
-    }
-
-    println(vosk.VoskFinalResult(rec, buffer))
-}

go/example/test_simple.go

@@ -0,0 +1,67 @@
+package main
+
+import (
+	"bufio"
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"os"
+
+	vosk "github.com/alphacep/vosk-api/go"
+)
+
+func main() {
+	var filename string
+	flag.StringVar(&filename, "f", "", "file to transcribe")
+	flag.Parse()
+
+	model, err := vosk.NewModel("model")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	spkModel, err := vosk.NewSpkModel("model-spk")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	sampleRate := 16000.0
+	rec, err := vosk.NewRecognizer(model, sampleRate, spkModel)
+	if err != nil {
+		log.Fatal(err)
+	}
+	rec.SetWords(1)
+
+	file, err := os.Open(filename)
+	if err != nil {
+		panic(err)
+	}
+	defer file.Close()
+
+	file, err := os.Open(filename)
+	if err != nil {
+		panic(err)
+	}
+	defer file.Close()
+
+	reader := bufio.NewReader(file)
+	buf := make([]byte, 4096)
+
+	for {
+		_, err := reader.Read(buf)
+		if err != nil {
+			if err != io.EOF {
+				log.Fatal(err)
+			}
+
+			break
+		}
+
+		if rec.AcceptWaveform(buf) != 0 {
+			fmt.Println(string(rec.Result()))
+		}
+	}
+
+	fmt.Println(string(rec.FinalResult()))
+}

go/go.mod

@@ -0,0 +1,7 @@
+module github.com/alphacep/vosk-api/go
+
+go 1.16
+
+replace (
+    github.com/alphacep/vosk-api/go => ./
+)

go/vosk.go

@@ -8,55 +8,133 @@ import "C"
 
 // VoskModel contains a reference to the C VoskModel
 type VoskModel struct {
-    model *C.struct_VoskModel
-}
-
-// VoskSpkModel contains a reference to the C VoskSpkModel
-type VoskSpkModel struct {
-    spkModel *C.struct_VoskSpkModel
-}
-
-// VoskRecognizer contains a reference to the C VoskRecognizer
-type VoskRecognizer struct {
-    rec *C.struct_VoskRecognizer
-}
-
-func VoskFinalResult(recognizer *VoskRecognizer, buffer []byte) string {
-    cbuf := C.CBytes(buffer)
-    defer C.free(cbuf)
-    _ = C.vosk_recognizer_accept_waveform(recognizer.rec, (*C.char)(cbuf), C.int(len(buffer)))
-    result := C.GoString(C.vosk_recognizer_final_result(recognizer.rec))
-    return result
+	model *C.struct_VoskModel
 }
 
 // NewModel creates a new VoskModel instance
 func NewModel(modelPath string) (*VoskModel, error) {
-    var internal *C.struct_VoskModel
-    internal = C.vosk_model_new(C.CString(modelPath))
-    model := &VoskModel{model: internal}
-    return model, nil
-}
-
-// NewRecognizer creates a new VoskRecognizer instance
-func NewRecognizer(model *VoskModel) (*VoskRecognizer, error) {
-    var internal *C.struct_VoskRecognizer
-    internal = C.vosk_recognizer_new(model.model, 16000.0)
-    rec := &VoskRecognizer{rec: internal}
-    return rec, nil
+	internal := C.vosk_model_new(C.CString(modelPath))
+	model := &VoskModel{model: internal}
+	return model, nil
 }
 
 func freeModel(model *VoskModel) {
-    C.vosk_model_free(model.model)
+	C.vosk_model_free(model.model)
 }
 
-func freeRecognizer(recognizer *VoskRecognizer) {
-    C.vosk_recognizer_free(recognizer.rec)
+// FindWord checks if a word can be recognized by the model.
+// Returns the word symbol if the word exists inside the model or
+// -1 otherwise.
+func (m *VoskModel) FindWord(word []byte) int {
+	cbuf := C.CBytes(word)
+	defer C.free(cbuf)
+	i := C.vosk_model_find_word(m.model, (*C.char)(cbuf))
+	return int(i)
+}
+
+// VoskSpkModel contains a reference to the C VoskSpkModel
+type VoskSpkModel struct {
+	spkModel *C.struct_VoskSpkModel
 }
 
 // NewSpkModel creates a new VoskSpkModel instance
 func NewSpkModel(spkModelPath string) (*VoskSpkModel, error) {
-    var internal *C.struct_VoskSpkModel
-    internal = C.vosk_spk_model_new(C.CString(spkModelPath))
-    spkModel := &VoskSpkModel{spkModel: internal}
-    return spkModel, nil
+	internal := C.vosk_spk_model_new(C.CString(spkModelPath))
+	spkModel := &VoskSpkModel{spkModel: internal}
+	return spkModel, nil
+}
+
+func freeSpkModel(model *VoskSpkModel) {
+	C.vosk_spk_model_free(model.spkModel)
+}
+
+// VoskRecognizer contains a reference to the C VoskRecognizer
+type VoskRecognizer struct {
+	rec *C.struct_VoskRecognizer
+}
+
+func freeRecognizer(recognizer *VoskRecognizer) {
+	C.vosk_recognizer_free(recognizer.rec)
+}
+
+// NewRecognizer creates a new VoskRecognizer instance
+func NewRecognizer(model *VoskModel, sampleRate float64) (*VoskRecognizer, error) {
+	internal := C.vosk_recognizer_new(model.model, C.float(sampleRate))
+	rec := &VoskRecognizer{rec: internal}
+	return rec, nil
+}
+
+// NewRecognizerSpk creates a new VoskRecognizer instance with a speaker model.
+func NewRecognizerSpk(model *VoskModel, sampleRate float64, spkModel *VoskSpkModel) (*VoskRecognizer, error) {
+	internal := C.vosk_recognizer_new_spk(model.model, C.float(sampleRate), spkModel.spkModel)
+	rec := &VoskRecognizer{rec: internal}
+	return rec, nil
+}
+
+// NewRecognizerGrm creates a new VoskRecognizer instance with the phrase list.
+func NewRecognizerGrm(model *VoskModel, sampleRate float64, grammer []byte) (*VoskRecognizer, error) {
+	cbuf := C.CBytes(grammer)
+	defer C.free(cbuf)
+	internal := C.vosk_recognizer_new_grm(model.model, C.float(sampleRate), (*C.char)(cbuf))
+	rec := &VoskRecognizer{rec: internal}
+	return rec, nil
+}
+
+// SetSpkModel adds a speaker model to an already initialized recognizer.
+func (r *VoskRecognizer) SetSpkModel(spkModel *VoskSpkModel) {
+	C.vosk_recognizer_set_spk_model(r.rec, spkModel.spkModel)
+}
+
+// SetMaxAlternatives configures the recognizer to output n-best results.
+func (r *VoskRecognizer) SetMaxAlternatives(maxAlternatives int) {
+	C.vosk_recognizer_set_max_alternatives(r.rec, C.int(maxAlternatives))
+}
+
+// SetWords enables words with times in the ouput.
+func (r *VoskRecognizer) SetWords(words int) {
+	C.vosk_recognizer_set_words(r.rec, C.int(words))
+}
+
+// AcceptWaveform accepts and processes a new chunk of the voice data.
+func (r *VoskRecognizer) AcceptWaveform(buffer []byte) int {
+	cbuf := C.CBytes(buffer)
+	defer C.free(cbuf)
+	i := C.vosk_recognizer_accept_waveform(r.rec, (*C.char)(cbuf), C.int(len(buffer)))
+	return int(i)
+}
+
+// Result returns a speech recognition result.
+func (r *VoskRecognizer) Result() []byte {
+	return []byte(C.GoString(C.vosk_recognizer_result(r.rec)))
+}
+
+// PartialResult returns a partial speech recognition result.
+func (r *VoskRecognizer) PartialResult() []byte {
+	return []byte(C.GoString(C.vosk_recognizer_result(r.rec)))
+}
+
+// FinalResult returns a speech recognition result. Same as result, but doesn't wait
+// for silence.
+func (r *VoskRecognizer) FinalResult() []byte {
+	return []byte(C.GoString(C.vosk_recognizer_final_result(r.rec)))
+}
+
+// Reset resets the recognizer.
+func (r *VoskRecognizer) Reset() {
+	C.vosk_recognizer_reset(r.rec)
+}
+
+// SetLogLevel sets the log level for Kaldi messages.
+func SetLogLevel(logLevel int) {
+	C.vosk_set_log_level(C.int(logLevel))
+}
+
+// GPUInit automatically selects a CUDA device and allows multithreading.
+func GPUInit() {
+	C.vosk_gpu_init()
+}
+
+// GPUThreadInit inits CUDA device in a multi-threaded environment.
+func GPUThreadInit() {
+	C.vosk_gpu_thread_init()
 }

python/setup.py

@@ -44,7 +44,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="vosk",
-    version="0.3.30",
+    version="0.3.31",
     author="Alpha Cephei Inc",
     author_email="contact@alphacephei.com",
     description="Offline open source speech recognition API based on Kaldi and Vosk",

src/Makefile

@@ -1,13 +1,19 @@
+# Locations of the dependencies
 KALDI_ROOT?=$(HOME)/travis/kaldi
 OPENFST_ROOT?=$(KALDI_ROOT)/tools/openfst
 OPENBLAS_ROOT?=$(KALDI_ROOT)/tools/OpenBLAS/install
-HAVE_CUDA?=0
+MKL_ROOT?=/opt/intel/mkl
 CUDA_ROOT?=/usr/local/cuda
-EXT?=so
-CXX?=g++
-HAVE_OPENBLAS_CLAPACK=1
+# Math libraries
+HAVE_OPENBLAS_CLAPACK?=1
+HAVE_MKL?=0
 HAVE_ACCELERATE=0
-EXTRA_CFLGAS?=
+HAVE_CUDA?=0
+# Compiler
+CXX?=g++
+EXT?=so
+# Extra
+EXTRA_CFLAGS?=
 EXTRA_LDFLAGS?=
 
 VOSK_SOURCES= \
@@ -17,8 +23,8 @@ VOSK_SOURCES= \
 	spk_model.cc \
 	vosk_api.cc
 
-CFLAGS=-g -O2 -std=c++17 -fPIC -DFST_NO_DYNAMIC_LINKING $(EXTRA_CFLAGS) \
-	-I. -I$(KALDI_ROOT)/src -I$(OPENFST_ROOT)/include -I$(OPENBLAS_ROOT)/include
+CFLAGS=-g -O3 -std=c++17 -fPIC -DFST_NO_DYNAMIC_LINKING \
+	-I. -I$(KALDI_ROOT)/src -I$(OPENFST_ROOT)/include $(EXTRA_CFLAGS) 
 
 LIBS= \
 	$(KALDI_ROOT)/src/online2/kaldi-online2.a \
@@ -43,21 +49,26 @@ LIBS= \
 
 
 ifeq ($(HAVE_OPENBLAS_CLAPACK), 1)
-LIBS += \
-	$(OPENBLAS_ROOT)/lib/libopenblas.a \
-	$(OPENBLAS_ROOT)/lib/liblapack.a \
-	$(OPENBLAS_ROOT)/lib/libblas.a \
-	$(OPENBLAS_ROOT)/lib/libf2c.a
+    CFLAGS += -I$(OPENBLAS_ROOT)/include
+    LIBS += \
+        $(OPENBLAS_ROOT)/lib/libopenblas.a \
+        $(OPENBLAS_ROOT)/lib/liblapack.a \
+        $(OPENBLAS_ROOT)/lib/libblas.a \
+        $(OPENBLAS_ROOT)/lib/libf2c.a
+endif
+
+ifeq ($(HAVE_MKL), 1)
+    CFLAGS += -I$(MKL_ROOT)/include
+    LIBS += -L$(MKL_ROOT)/lib/intel64 -Wl,-rpath=$(MKL_ROOT)/lib/intel64 -lmkl_rt -lmkl_intel_lp64 -lmkl_core -lmkl_sequential
 endif
 
 ifeq ($(HAVE_ACCELERATE), 1)
-LIBS += \
-	-framework Accelerate
+    LIBS += -framework Accelerate
 endif
 
 ifeq ($(HAVE_CUDA), 1)
-CFLAGS+=-DHAVE_CUDA=1 -I$(CUDA_ROOT)/include
-LIBS+=-L$(CUDA_ROOT)/lib64 -lcublas -lcusparse -lcudart -lcurand -lcufft -lcusolver -lnvToolsExt
+    CFLAGS+=-DHAVE_CUDA=1 -I$(CUDA_ROOT)/include
+    LIBS+=-L$(CUDA_ROOT)/lib64 -lcublas -lcusparse -lcudart -lcurand -lcufft -lcusolver -lnvToolsExt
 endif
 
 all: libvosk.$(EXT)

src/kaldi_recognizer.cc

@@ -142,13 +142,14 @@ KaldiRecognizer::~KaldiRecognizer() {
     delete g_fst_;
     delete decode_fst_;
     delete spk_feature_;
-    delete lm_fst_;
 
-    delete info;
-    delete lm_to_subtract_det_backoff;
-    delete lm_to_subtract_det_scale;
-    delete lm_to_add_orig;
-    delete lm_to_add;
+    delete rnnlm_info_;
+    delete lm_to_subtract_;
+    delete lm_to_subtract_scale_;
+    delete carpa_to_add_;
+    delete carpa_to_add_scale_;
+    delete rnnlm_to_add_;
+    delete rnnlm_to_add_scale_;
 
     model_->Unref();
     if (spk_model_)
@@ -166,21 +167,18 @@ void KaldiRecognizer::InitState()
 
 void KaldiRecognizer::InitRescoring()
 {
-    if (model_->rnnlm_lm_fst_) {
-        float lm_scale = 0.5;
-        int lm_order = 4;
+    if (model_->graph_lm_fst_) {
+        lm_to_subtract_ = new fst::BackoffDeterministicOnDemandFst<StdArc>(*model_->graph_lm_fst_);
+        lm_to_subtract_scale_ = new fst::ScaleDeterministicOnDemandFst(-1.0, lm_to_subtract_);
+        carpa_to_add_ = new ConstArpaLmDeterministicFst(model_->const_arpa_);
 
-        info = new kaldi::rnnlm::RnnlmComputeStateInfo(model_->rnnlm_compute_opts, model_->rnnlm, model_->word_embedding_mat);
-        lm_to_subtract_det_backoff = new fst::BackoffDeterministicOnDemandFst<fst::StdArc>(*model_->rnnlm_lm_fst_);
-        lm_to_subtract_det_scale = new fst::ScaleDeterministicOnDemandFst(-lm_scale, lm_to_subtract_det_backoff);
-        lm_to_add_orig = new kaldi::rnnlm::KaldiRnnlmDeterministicFst(lm_order, *info);
-        lm_to_add = new fst::ScaleDeterministicOnDemandFst(lm_scale, lm_to_add_orig);
-
-    } else if (model_->std_lm_fst_) {
-        fst::CacheOptions cache_opts(true, 50000);
-        fst::ArcMapFstOptions mapfst_opts(cache_opts);
-        fst::StdToLatticeMapper<kaldi::BaseFloat> mapper;
-        lm_fst_ = new fst::ArcMapFst<fst::StdArc, kaldi::LatticeArc, fst::StdToLatticeMapper<kaldi::BaseFloat> >(*model_->std_lm_fst_, mapper, mapfst_opts);
+        if (model_->rnnlm_enabled_) {
+           int lm_order = 4;
+           rnnlm_info_ = new kaldi::rnnlm::RnnlmComputeStateInfo(model_->rnnlm_compute_opts, model_->rnnlm, model_->word_embedding_mat);
+           rnnlm_to_add_ = new kaldi::rnnlm::KaldiRnnlmDeterministicFst(lm_order, *rnnlm_info_);
+           rnnlm_to_add_scale_ = new fst::ScaleDeterministicOnDemandFst(0.5, rnnlm_to_add_);
+           carpa_to_add_scale_ = new fst::ScaleDeterministicOnDemandFst(-0.5, carpa_to_add_);
+        }
     }
 }
 
@@ -592,38 +590,30 @@ const char* KaldiRecognizer::GetResult()
     kaldi::CompactLattice rlat;
     decoder_->GetLattice(true, &clat);
 
-    if (model_->rnnlm_lm_fst_) {
-        kaldi::ComposeLatticePrunedOptions compose_opts;
-        compose_opts.lattice_compose_beam = 3.0;
-        compose_opts.max_arcs = 3000;
-
+    if (lm_to_subtract_scale_ && carpa_to_add_) {
         TopSortCompactLatticeIfNeeded(&clat);
-        fst::ComposeDeterministicOnDemandFst<fst::StdArc> combined_lms(lm_to_subtract_det_scale, lm_to_add);
-        CompactLattice composed_clat;
-        ComposeCompactLatticePruned(compose_opts, clat,
-                                    &combined_lms, &rlat);
-        lm_to_add_orig->Clear();
-    } else if (model_->std_lm_fst_) {
-        Lattice lat1;
+        CompactLattice tlat;
+        fst::ComposeDeterministicOnDemandFst<StdArc> combined_lm(lm_to_subtract_scale_, carpa_to_add_);
+        ComposeCompactLatticeDeterministic(clat, &combined_lm, &tlat);
 
-        ConvertLattice(clat, &lat1);
-        fst::ScaleLattice(fst::GraphLatticeScale(-1.0), &lat1);
-        fst::ArcSort(&lat1, fst::OLabelCompare<kaldi::LatticeArc>());
-        kaldi::Lattice composed_lat;
-        fst::Compose(lat1, *lm_fst_, &composed_lat);
-        fst::Invert(&composed_lat);
-        kaldi::CompactLattice determinized_lat;
-        DeterminizeLattice(composed_lat, &determinized_lat);
-        fst::ScaleLattice(fst::GraphLatticeScale(-1), &determinized_lat);
-        fst::ArcSort(&determinized_lat, fst::OLabelCompare<kaldi::CompactLatticeArc>());
+        if (rnnlm_to_add_scale_) {
+             ComposeLatticePrunedOptions compose_opts;
+             compose_opts.lattice_compose_beam = 3.0;
+             compose_opts.max_arcs = 3000;
+             TopSortCompactLatticeIfNeeded(&tlat);
+             fst::ComposeDeterministicOnDemandFst<StdArc> combined_rnnlm(carpa_to_add_scale_, rnnlm_to_add_scale_);
+             ComposeCompactLatticePruned(compose_opts, tlat,
+                                         &combined_rnnlm, &rlat);
+             rnnlm_to_add_->Clear();
+        } else {
+             rlat = tlat;
+        }
+
+        kaldi::Lattice slat;
+        ConvertLattice(rlat, &slat);
+        fst::Invert(&slat);
+        DeterminizeLattice(slat, &rlat);
 
-        kaldi::ConstArpaLmDeterministicFst const_arpa_fst(model_->const_arpa_);
-        kaldi::CompactLattice composed_clat;
-        kaldi::ComposeCompactLatticeDeterministic(determinized_lat, &const_arpa_fst, &composed_clat);
-        kaldi::Lattice composed_lat1;
-        ConvertLattice(composed_clat, &composed_lat1);
-        fst::Invert(&composed_lat1);
-        DeterminizeLattice(composed_lat1, &rlat);
     } else {
         rlat = clat;
     }

src/kaldi_recognizer.h

@@ -82,15 +82,18 @@ class KaldiRecognizer {
         OnlineBaseFeature *spk_feature_ = nullptr;
 
         // Rescoring
-        fst::ArcMapFst<fst::StdArc, kaldi::LatticeArc, fst::StdToLatticeMapper<kaldi::BaseFloat> > *lm_fst_ = nullptr;
+        fst::BackoffDeterministicOnDemandFst<fst::StdArc> *lm_to_subtract_ = nullptr;
+        fst::ScaleDeterministicOnDemandFst *lm_to_subtract_scale_ = nullptr;
+        kaldi::ConstArpaLmDeterministicFst *carpa_to_add_ = nullptr;
+        fst::ScaleDeterministicOnDemandFst *carpa_to_add_scale_ = nullptr;
 
         // RNNLM rescoring
-        kaldi::rnnlm::RnnlmComputeStateInfo *info = nullptr;
-        fst::ScaleDeterministicOnDemandFst *lm_to_subtract_det_scale = nullptr;
-        fst::BackoffDeterministicOnDemandFst<fst::StdArc> *lm_to_subtract_det_backoff = nullptr;
-        kaldi::rnnlm::KaldiRnnlmDeterministicFst* lm_to_add_orig = nullptr;
-        fst::DeterministicOnDemandFst<fst::StdArc> *lm_to_add = nullptr;
+        kaldi::rnnlm::KaldiRnnlmDeterministicFst* rnnlm_to_add_ = nullptr;
+        fst::DeterministicOnDemandFst<fst::StdArc> *rnnlm_to_add_scale_ = nullptr;
+        kaldi::rnnlm::RnnlmComputeStateInfo *rnnlm_info_ = nullptr;
 
+
+        // Other
         int max_alternatives_ = 0; // Disable alternatives by default
         bool words_ = false;
 

src/model.cc

@@ -174,7 +174,6 @@ void Model::ConfigureV1()
     rnnlm_feat_embedding_rxfilename_ = model_path_str_ + "/rnnlm/feat_embedding.final.mat";
     rnnlm_config_rxfilename_ = model_path_str_ + "/rnnlm/special_symbol_opts.conf";
     rnnlm_lm_rxfilename_ = model_path_str_ + "/rnnlm/final.raw";
-    rnnlm_lm_fst_rxfilename_ = model_path_str_ + "/rescore/G.fst";
 }
 
 void Model::ConfigureV2()
@@ -203,7 +202,6 @@ void Model::ConfigureV2()
     rnnlm_feat_embedding_rxfilename_ = model_path_str_ + "/rnnlm/feat_embedding.final.mat";
     rnnlm_config_rxfilename_ = model_path_str_ + "/rnnlm/special_symbol_opts.conf";
     rnnlm_lm_rxfilename_ = model_path_str_ + "/rnnlm/final.raw";
-    rnnlm_lm_fst_rxfilename_ = model_path_str_ + "/rescore/G.fst";
 }
 
 void Model::ReadDataFiles()
@@ -296,12 +294,19 @@ void Model::ReadDataFiles()
         winfo_ = new kaldi::WordBoundaryInfo(opts, winfo_rxfilename_);
     }
 
+    if (stat(carpa_rxfilename_.c_str(), &buffer) == 0) {
+
+        KALDI_LOG << "Loading subtract G.fst model from " << std_fst_rxfilename_;
+        graph_lm_fst_ = fst::ReadAndPrepareLmFst(std_fst_rxfilename_);
+        KALDI_LOG << "Loading CARPA model from " << carpa_rxfilename_;
+        ReadKaldiObject(carpa_rxfilename_, &const_arpa_);
+    }
+
     // RNNLM Rescoring
     if (stat(rnnlm_lm_rxfilename_.c_str(), &buffer) == 0) {
         KALDI_LOG << "Loading RNNLM model from " << rnnlm_lm_rxfilename_;
 
         ReadKaldiObject(rnnlm_lm_rxfilename_, &rnnlm);
-        rnnlm_lm_fst_ = fst::ReadAndPrepareLmFst(rnnlm_lm_fst_rxfilename_);
         Matrix<BaseFloat> feature_embedding_mat;
         ReadKaldiObject(rnnlm_feat_embedding_rxfilename_, &feature_embedding_mat);
         SparseMatrix<BaseFloat> word_feature_mat;
@@ -319,17 +324,9 @@ void Model::ReadDataFiles()
 
         ReadConfigFromFile(rnnlm_config_rxfilename_, &rnnlm_compute_opts);
 
-    } else if (stat(carpa_rxfilename_.c_str(), &buffer) == 0) {
-
-        KALDI_LOG << "Loading CARPA model from " << carpa_rxfilename_;
-        std_lm_fst_ = fst::ReadFstKaldi(std_fst_rxfilename_);
-        fst::Project(std_lm_fst_, fst::ProjectType::OUTPUT);
-        if (std_lm_fst_->Properties(fst::kILabelSorted, true) == 0) {
-            fst::ILabelCompare<fst::StdArc> ilabel_comp;
-            fst::ArcSort(std_lm_fst_, ilabel_comp);
-        }
-        ReadKaldiObject(carpa_rxfilename_, &const_arpa_);
+        rnnlm_enabled_ = true;
     }
+
 }
 
 void Model::Ref() 
@@ -363,5 +360,5 @@ Model::~Model() {
     delete hclg_fst_;
     delete hcl_fst_;
     delete g_fst_;
-    delete std_lm_fst_;
+    delete graph_lm_fst_;
 }

src/model.h

@@ -72,7 +72,6 @@ protected:
     string rnnlm_word_feats_rxfilename_;
     string rnnlm_feat_embedding_rxfilename_;
     string rnnlm_config_rxfilename_;
-    string rnnlm_lm_fst_rxfilename_;
     string rnnlm_lm_rxfilename_;
 
     kaldi::OnlineEndpointConfig endpoint_config_;
@@ -92,13 +91,13 @@ protected:
     fst::Fst<fst::StdArc> *hcl_fst_ = nullptr;
     fst::Fst<fst::StdArc> *g_fst_ = nullptr;
 
-    fst::VectorFst<fst::StdArc> *std_lm_fst_ = nullptr;
+    fst::VectorFst<fst::StdArc> *graph_lm_fst_ = nullptr;
     kaldi::ConstArpaLm const_arpa_;
 
     kaldi::rnnlm::RnnlmComputeStateComputationOptions rnnlm_compute_opts;
     CuMatrix<BaseFloat> word_embedding_mat;
-    fst::VectorFst<fst::StdArc> *rnnlm_lm_fst_ = NULL;
     kaldi::nnet3::Nnet rnnlm;
+    bool rnnlm_enabled_ = false;
 
     std::atomic<int> ref_cnt_;
 };