+.PHONY: kaldi

+SHELL := /bin/bash

+BUILD_DIR := $(CURDIR)/build

+INC_PATH := $(LUA_BINDIR)/../include/

+OBJS := init.o src/cwrapper_kaldi.o src/init.o

+LIBS := libkaldiio.so

+LUA_LIBS := init.lua

+INCLUDE := -I $(LUA_INCDIR) -I $(INC_PATH) -DLUA_USE_APICHECK

+

+SUBDIR := src

+OBJ_DIR := $(BUILD_DIR)/objs

+LUA_DIR := $(INST_LUADIR)/kaldi_io

+KALDIINCLUDE := -I src/tools/ATLAS/include/ -I src/kaldi/ -I src/tools/openfst/include/

+

+OBJS := $(addprefix $(OBJ_DIR)/,$(OBJS))

+LIBS := $(addprefix $(INST_LIBDIR)/,$(LIBS))

+OBJ_SUBDIR := $(addprefix $(OBJ_DIR)/,$(SUBDIR))

+LUA_SUBDIR := $(addprefix $(LUA_DIR)/,$(SUBDIR))

+LUA_LIBS := $(addprefix $(LUA_DIR)/,$(LUA_LIBS))

+LIB_PATH := $(LUA_BINDIR)/../lib

+

+build: $(OBJ_DIR) $(OBJ_SUBDIR) $(OBJS) $(OBJ_DIR)/src/test

+install: $(LUA_DIR) $(LUA_SUBDIR) $(LUA_LIBS) $(LIBS)

+

+include kaldi.mk

+

+KL := /home/stuymf/kaldi-trunk/src/feat/kaldi-feat.a /home/stuymf/kaldi-trunk/src/matrix/kaldi-matrix.a /home/stuymf/kaldi-trunk/src/base/kaldi-base.a /home/stuymf/kaldi-trunk/src/util/kaldi-util.a /home/stuymf/kaldi-trunk/src/hmm/kaldi-hmm.a /home/stuymf/kaldi-trunk/src/tree/kaldi-tree.a /usr/lib/libatlas.so.3 /usr/lib/libf77blas.so.3 /usr/lib/libcblas.so.3 /usr/lib/liblapack_atlas.so.3

+

+

+$(OBJ_DIR) $(LUA_DIR) $(OBJ_SUBDIR) $(LUA_SUBDIR):

+ -mkdir -p $@

+$(LUA_DIR)/%.lua: %.lua

+ cp $< $@

+$(LIBS): $(OBJ_DIR)/src/cwrapper_kaldi.o $(OBJ_DIR)/init.o $(OBJ_DIR)/src/init.o

+ gcc -shared -o $@ $(OBJ_DIR)/src/cwrapper_kaldi.o $(OBJ_DIR)/init.o $(OBJ_DIR)/src/init.o -lstdc++ -Wl,-rpath=$(LIB_PATH) -L$(LIB_PATH) -lnervcore -lluaT $(KL)

+ g++ -o $@ -c $< -DHAVE_ATLAS $(KALDIINCLUDE) -g -fPIC $(INCLUDE) -DKALDI_DOUBLEPRECISION=0 -msse2 -DHAVE_POSIX_MEMALIGN

+$(OBJ_DIR)/src/cwrapper_kaldi.o: src/cwrapper_kaldi.cpp

+ g++ -o $@ -c $< -DHAVE_ATLAS $(KALDIINCLUDE) -g -fPIC $(INCLUDE) -DKALDI_DOUBLEPRECISION=0 -msse2 -DHAVE_POSIX_MEMALIGN

+$(OBJ_DIR)/src/test: $(OBJ_DIR)/src/cwrapper_kaldi.o $(OBJ_DIR)/src/test.o

+ gcc -o $@ $^ -Wl,-rpath=$(LIB_PATH) -L$(LIB_PATH) $(INCLUDE) $(KALDIINCLUDE) -lnervcore -Wl,-rpath=$(LUA_LIBDIR) -L$(LUA_LIBDIR) -lluajit-5.1 -lstdc++ -lm $(KL)

+$(OBJ_DIR)/%.o: %.c

+ gcc -o $@ -c $< -g $(INCLUDE) -fPIC

+clean:

+ -rm $(OBJ_DIR)/src/*.o

+

+require 'kaldi_io'

+

+frm_ext = 5

+feat_repo = nerv.KaldiFeatureRepo("ark:/slfs6/users/ymz09/kaldi/src/featbin/copy-feats scp:/slfs6/users/ymz09/swb_ivec/train_bp.scp ark:- |")

+

+feat_utter = feat_repo:cur_utter(true)

+print(feat_utter)

+

+require 'kaldi_io'

+gconf = {lrate = 0.8, wcost = 1e-6, momentum = 0.9,

+ cumat_type = nerv.CuMatrixFloat,

+ mmat_type = nerv.MMatrixFloat,

+ frm_ext = 5,

+ tr_scp = "ark:/slfs6/users/ymz09/kaldi/src/featbin/copy-feats scp:/slfs6/users/ymz09/swb_ivec/train_bp.scp ark:- |",

+ cv_scp = "ark:/slfs6/users/ymz09/kaldi/src/featbin/copy-feats scp:/slfs6/users/ymz09/swb_ivec/train_cv.scp ark:- |",

+ initialized_param = {"/slfs6/users/ymz09/swb_ivec/swb_init.nerv",

+ "/slfs6/users/ymz09/swb_ivec/swb_global_transf.nerv"},

+ debug = false}

+

+function make_layer_repo(param_repo)

+ local layer_repo = nerv.LayerRepo(

+ {

+ -- global transf

+ ["nerv.BiasLayer"] =

+ {

+ blayer1 = {{bias = "bias1"}, {dim_in = {429}, dim_out = {429}}},

+ blayer2 = {{bias = "bias2"}, {dim_in = {429}, dim_out = {429}}}

+ },

+ ["nerv.WindowLayer"] =

+ {

+ wlayer1 = {{window = "window1"}, {dim_in = {429}, dim_out = {429}}},

+ wlayer2 = {{window = "window2"}, {dim_in = {429}, dim_out = {429}}}

+ },

+ -- biased linearity

+ ["nerv.AffineLayer"] =

+ {

+ affine0 = {{ltp = "affine0_ltp", bp = "affine0_bp"},

+ {dim_in = {429}, dim_out = {2048}}},

+ affine1 = {{ltp = "affine1_ltp", bp = "affine1_bp"},

+ {dim_in = {2048}, dim_out = {2048}}},

+ affine2 = {{ltp = "affine2_ltp", bp = "affine2_bp"},

+ {dim_in = {2048}, dim_out = {2048}}},

+ affine3 = {{ltp = "affine3_ltp", bp = "affine3_bp"},

+ {dim_in = {2048}, dim_out = {2048}}},

+ affine4 = {{ltp = "affine4_ltp", bp = "affine4_bp"},

+ {dim_in = {2048}, dim_out = {2048}}},

+ affine5 = {{ltp = "affine5_ltp", bp = "affine5_bp"},

+ {dim_in = {2048}, dim_out = {2048}}},

+ affine6 = {{ltp = "affine6_ltp", bp = "affine6_bp"},

+ {dim_in = {2048}, dim_out = {2048}}},

+ affine7 = {{ltp = "affine7_ltp", bp = "affine7_bp"},

+ {dim_in = {2048}, dim_out = {3001}}}

+ },

+ ["nerv.SigmoidLayer"] =

+ {

+ sigmoid0 = {{}, {dim_in = {2048}, dim_out = {2048}}},

+ sigmoid1 = {{}, {dim_in = {2048}, dim_out = {2048}}},

+ sigmoid2 = {{}, {dim_in = {2048}, dim_out = {2048}}},

+ sigmoid3 = {{}, {dim_in = {2048}, dim_out = {2048}}},

+ sigmoid4 = {{}, {dim_in = {2048}, dim_out = {2048}}},

+ sigmoid5 = {{}, {dim_in = {2048}, dim_out = {2048}}},

+ sigmoid6 = {{}, {dim_in = {2048}, dim_out = {2048}}}

+ },

+ ["nerv.SoftmaxCELayer"] = -- softmax + ce criterion layer for finetune output

+ {

+ ce_crit = {{}, {dim_in = {3001, 1}, dim_out = {1}, compressed = true}}

+ },

+ ["nerv.SoftmaxLayer"] = -- softmax for decode output

+ {

+ softmax = {{}, {dim_in = {3001}, dim_out = {3001}}}

+ }

+ }, param_repo, gconf)

+

+ layer_repo:add_layers(

+ {

+ ["nerv.DAGLayer"] =

+ {

+ global_transf = {{}, {

+ dim_in = {429}, dim_out = {429},

+ sub_layers = layer_repo,

+ connections = {

+ ["<input>[1]"] = "blayer1[1]",

+ ["blayer1[1]"] = "wlayer1[1]",

+ ["wlayer1[1]"] = "blayer2[1]",

+ ["blayer2[1]"] = "wlayer2[1]",

+ ["wlayer2[1]"] = "<output>[1]"

+ }

+ }},

+ main = {{}, {

+ dim_in = {429}, dim_out = {3001},

+ sub_layers = layer_repo,

+ connections = {

+ ["<input>[1]"] = "affine0[1]",

+ ["affine0[1]"] = "sigmoid0[1]",

+ ["sigmoid0[1]"] = "affine1[1]",

+ ["affine1[1]"] = "sigmoid1[1]",

+ ["sigmoid1[1]"] = "affine2[1]",

+ ["affine2[1]"] = "sigmoid2[1]",

+ ["sigmoid2[1]"] = "affine3[1]",

+ ["affine3[1]"] = "sigmoid3[1]",

+ ["sigmoid3[1]"] = "affine4[1]",

+ ["affine4[1]"] = "sigmoid4[1]",

+ ["sigmoid4[1]"] = "affine5[1]",

+ ["affine5[1]"] = "sigmoid5[1]",

+ ["sigmoid5[1]"] = "affine6[1]",

+ ["affine6[1]"] = "sigmoid6[1]",

+ ["sigmoid6[1]"] = "affine7[1]",

+ ["affine7[1]"] = "<output>[1]"

+ }

+ }}

+ }

+ }, param_repo, gconf)

+

+ layer_repo:add_layers(

+ {

+ ["nerv.DAGLayer"] =

+ {

+ ce_output = {{}, {

+ dim_in = {429, 1}, dim_out = {1},

+ sub_layers = layer_repo,

+ connections = {

+ ["<input>[1]"] = "main[1]",

+ ["main[1]"] = "ce_crit[1]",

+ ["<input>[2]"] = "ce_crit[2]",

+ ["ce_crit[1]"] = "<output>[1]"

+ }

+ }},

+ softmax_output = {{}, {

+ dim_in = {429}, dim_out = {3001},

+ sub_layers = layer_repo,

+ connections = {

+ ["<input>[1]"] = "main[1]",

+ ["main[1]"] = "softmax[1]",

+ ["softmax[1]"] = "<output>[1]"

+ }

+ }}

+ }

+ }, param_repo, gconf)

+

+ return layer_repo

+end

+

+function get_network(layer_repo)

+ return layer_repo:get_layer("ce_output")

+end

+

+function get_decode_network(layer_repo)

+ return layer_repo:get_layer("softmax_output")

+end

+

+function get_global_transf(layer_repo)

+ return layer_repo:get_layer("global_transf")

+end

+

+function make_readers(feature_rspecifier, layer_repo)

+ return {

+ {reader = nerv.KaldiReader(gconf,

+ {

+ id = "main_scp",

+ feature_rspecifier = feature_rspecifier,

+ frm_ext = gconf.frm_ext,

+ mlfs = {

+ phone_state = {

+ targets_rspecifier = "ark:/slfs6/users/ymz09/kaldi/src/bin/ali-to-pdf /slfs6/users/ymz09/swb_ivec/final.mdl \"ark:gunzip -c /slfs6/users/ymz09/swb_ivec/ali.*.gz |\" ark:- | /slfs6/users/ymz09/kaldi/src/bin/ali-to-post ark:- ark:- |",

+ format = "map"

+ }

+ },

+ global_transf = layer_repo:get_layer("global_transf")

+ }),

+ data = {main_scp = 429, phone_state = 1}}

+ }

+end

+

+function make_buffer(readers)

+ return nerv.SGDBuffer(gconf,

+ {

+ buffer_size = gconf.buffer_size,

+ randomize = gconf.randomize,

+ readers = readers

+ })

+end

+

+function get_input_order()

+ return {"main_scp", "phone_state"}

+end

+

+function get_accuracy(layer_repo)

+ local ce_crit = layer_repo:get_layer("ce_crit")

+ return ce_crit.total_correct / ce_crit.total_frames * 100

+end

+

+function print_stat(layer_repo)

+ local ce_crit = layer_repo:get_layer("ce_crit")

+ nerv.info("*** training stat begin ***")

+ nerv.printf("cross entropy:\t\t%.8f\n", ce_crit.total_ce)

+ nerv.printf("correct:\t\t%d\n", ce_crit.total_correct)

+ nerv.printf("frames:\t\t\t%d\n", ce_crit.total_frames)

+ nerv.printf("err/frm:\t\t%.8f\n", ce_crit.total_ce / ce_crit.total_frames)

+ nerv.printf("accuracy:\t\t%.3f%%\n", get_accuracy(layer_repo))

+ nerv.info("*** training stat end ***")

+end

+require 'kaldi_io'

+gconf = {lrate = 0.8, wcost = 1e-6, momentum = 0.9,

+ cumat_type = nerv.CuMatrixFloat,

+ mmat_type = nerv.MMatrixFloat,

+ frm_ext = 5,

+ tr_rspecifier = "ark:/slfs6/users/ymz09/kaldi/src/featbin/copy-feats scp:/slfs6/users/ymz09/swb_ivec/train_bp.scp ark:- |",

+ cv_rspecifier = "ark:/slfs6/users/ymz09/kaldi/src/featbin/copy-feats scp:/slfs6/users/ymz09/swb_ivec/train_cv.scp ark:- |",

+ initialized_param = {"/slfs6/users/ymz09/swb_ivec/swb_init.nerv",

+ "/slfs6/users/ymz09/swb_ivec/swb_global_transf.nerv"},

+ debug = false}

+

+function make_sublayer_repo(param_repo)

+ return nerv.LayerRepo(

+ {

+ -- global transf

+ ["nerv.BiasLayer"] =

+ {

+ blayer1 = {{bias = "bias1"}, {dim_in = {429}, dim_out = {429}}},

+ blayer2 = {{bias = "bias2"}, {dim_in = {429}, dim_out = {429}}}

+ },

+ ["nerv.WindowLayer"] =

+ {

+ wlayer1 = {{window = "window1"}, {dim_in = {429}, dim_out = {429}}},

+ wlayer2 = {{window = "window2"}, {dim_in = {429}, dim_out = {429}}}

+ },

+ -- biased linearity

+ ["nerv.AffineLayer"] =

+ {

+ affine0 = {{ltp = "affine0_ltp", bp = "affine0_bp"},

+ {dim_in = {429}, dim_out = {2048}}},

+ affine1 = {{ltp = "affine1_ltp", bp = "affine1_bp"},

+ {dim_in = {2048}, dim_out = {2048}}},

+ affine2 = {{ltp = "affine2_ltp", bp = "affine2_bp"},

+ {dim_in = {2048}, dim_out = {2048}}},

+ affine3 = {{ltp = "affine3_ltp", bp = "affine3_bp"},

+ {dim_in = {2048}, dim_out = {2048}}},

+ affine4 = {{ltp = "affine4_ltp", bp = "affine4_bp"},

+ {dim_in = {2048}, dim_out = {2048}}},

+ affine5 = {{ltp = "affine5_ltp", bp = "affine5_bp"},

+ {dim_in = {2048}, dim_out = {2048}}},

+ affine6 = {{ltp = "affine6_ltp", bp = "affine6_bp"},

+ {dim_in = {2048}, dim_out = {2048}}},

+ affine7 = {{ltp = "affine7_ltp", bp = "affine7_bp"},

+ {dim_in = {2048}, dim_out = {3001}}}

+ },

+ ["nerv.SigmoidLayer"] =

+ {

+ sigmoid0 = {{}, {dim_in = {2048}, dim_out = {2048}}},

+ sigmoid1 = {{}, {dim_in = {2048}, dim_out = {2048}}},

+ sigmoid2 = {{}, {dim_in = {2048}, dim_out = {2048}}},

+ sigmoid3 = {{}, {dim_in = {2048}, dim_out = {2048}}},

+ sigmoid4 = {{}, {dim_in = {2048}, dim_out = {2048}}},

+ sigmoid5 = {{}, {dim_in = {2048}, dim_out = {2048}}},

+ sigmoid6 = {{}, {dim_in = {2048}, dim_out = {2048}}}

+ },

+ ["nerv.SoftmaxCELayer"] =

+ {

+ ce_crit = {{}, {dim_in = {3001, 1}, dim_out = {1}, compressed = true}}

+ }

+ }, param_repo, gconf)

+end

+

+function make_layer_repo(sublayer_repo, param_repo)

+ return nerv.LayerRepo(

+ {

+ ["nerv.DAGLayer"] =

+ {

+ global_transf = {{}, {

+ dim_in = {429}, dim_out = {429},

+ sub_layers = sublayer_repo,

+ connections = {

+ ["<input>[1]"] = "blayer1[1]",

+ ["blayer1[1]"] = "wlayer1[1]",

+ ["wlayer1[1]"] = "blayer2[1]",

+ ["blayer2[1]"] = "wlayer2[1]",

+ ["wlayer2[1]"] = "<output>[1]"

+ }

+ }},

+ main = {{}, {

+ dim_in = {429, 1}, dim_out = {1},

+ sub_layers = sublayer_repo,

+ connections = {

+ ["<input>[1]"] = "affine0[1]",

+ ["affine0[1]"] = "sigmoid0[1]",

+ ["sigmoid0[1]"] = "affine1[1]",

+ ["affine1[1]"] = "sigmoid1[1]",

+ ["sigmoid1[1]"] = "affine2[1]",

+ ["affine2[1]"] = "sigmoid2[1]",

+ ["sigmoid2[1]"] = "affine3[1]",

+ ["affine3[1]"] = "sigmoid3[1]",

+ ["sigmoid3[1]"] = "affine4[1]",

+ ["affine4[1]"] = "sigmoid4[1]",

+ ["sigmoid4[1]"] = "affine5[1]",

+ ["affine5[1]"] = "sigmoid5[1]",

+ ["sigmoid5[1]"] = "affine6[1]",

+ ["affine6[1]"] = "sigmoid6[1]",

+ ["sigmoid6[1]"] = "affine7[1]",

+ ["affine7[1]"] = "ce_crit[1]",

+ ["<input>[2]"] = "ce_crit[2]",

+ ["ce_crit[1]"] = "<output>[1]"

+ }

+ }}

+ }

+ }, param_repo, gconf)

+end

+

+function get_network(layer_repo)

+ return layer_repo:get_layer("main")

+end

+

+function make_readers(feature_rspecifier, layer_repo)

+ return {

+ {reader = nerv.KaldiReader(gconf,

+ {

+ id = "main_scp",

+ feature_rspecifier = feature_rspecifier,

+ frm_ext = gconf.frm_ext,

+ mlfs = {

+ phone_state = {

+ targets_rspecifier = "ark:/slfs6/users/ymz09/kaldi/src/bin/ali-to-pdf /slfs6/users/ymz09/swb_ivec/final.mdl \"ark:gunzip -c /slfs6/users/ymz09/swb_ivec/ali.*.gz |\" ark:- | /slfs6/users/ymz09/kaldi/src/bin/ali-to-post ark:- ark:- |",

+ format = "map"

+ }

+ },

+ global_transf = layer_repo:get_layer("global_transf")

+ }),

+ data = {main_scp = 429, phone_state = 1}}

+ }

+end

+

+function make_buffer(readers)

+ return nerv.SGDBuffer(gconf,

+ {

+ buffer_size = gconf.buffer_size,

+ randomize = gconf.randomize,

+ readers = readers

+ })

+end

+

+function get_input_order()

+ return {"main_scp", "phone_state"}

+end

+

+function get_accuracy(sublayer_repo)

+ local ce_crit = sublayer_repo:get_layer("ce_crit")

+ return ce_crit.total_correct / ce_crit.total_frames * 100

+end

+

+function print_stat(sublayer_repo)

+ local ce_crit = sublayer_repo:get_layer("ce_crit")

+ nerv.info("*** training stat begin ***")

+ nerv.printf("cross entropy:\t\t%.8f\n", ce_crit.total_ce)

+ nerv.printf("correct:\t\t%d\n", ce_crit.total_correct)

+ nerv.printf("frames:\t\t\t%d\n", ce_crit.total_frames)

+ nerv.printf("err/frm:\t\t%.8f\n", ce_crit.total_ce / ce_crit.total_frames)

+ nerv.printf("accuracy:\t\t%.3f%%\n", get_accuracy(sublayer_repo))

+ nerv.info("*** training stat end ***")

+end

+#include "../nerv/common.h"

+#include <stdio.h>

+

+extern void kaldi_io_init(lua_State *L);

+int luaopen_libkaldiio(lua_State *L) {

+ kaldi_io_init(L);

+ return 1;

+}

+require 'libkaldiio'

+require 'speech_utils'

+local KaldiReader = nerv.class("nerv.KaldiReader", "nerv.DataReader")

+

+function KaldiReader:__init(global_conf, reader_conf)

+ self.feat_id = reader_conf.id

+ self.frm_ext = reader_conf.frm_ext

+ self.gconf = global_conf

+ self.global_transf = reader_conf.global_transf

+ self.debug = global_conf.debug

+ if self.debug == nil then

+ self.debug = false

+ end

+ self.feat_repo = nerv.KaldiFeatureRepo(reader_conf.feature_rspecifier)

+

+ self.lab_repo = {}

+ for id, mlf_spec in pairs(reader_conf.mlfs) do

+ self.lab_repo[id] = nerv.KaldiLabelRepo(mlf_spec.targets_rspecifier,

+ mlf_spec.format)

+ end

+end

+

+function KaldiReader:get_data()

+ if self.feat_repo:is_end() then

+ return nil

+ end

+ local res = {}

+ -- read Kaldi feature

+ local feat_utter = self.feat_repo:cur_utter(self.debug)

+ -- global transf

+ local transformed = nerv.speech_utils.global_transf(feat_utter,

+ self.global_transf, self.frm_ext, 0, self.gconf)

+ res[self.feat_id] = transformed

+ -- add corresponding labels

+ for id, repo in pairs(self.lab_repo) do

+ local lab_utter = repo:get_utter(self.feat_repo,

+ self.frm_ext,

+ transformed:nrow(),

+ self.debug)

+ res[id] = lab_utter

+ --print(lab_utter)

+ end

+ -- move the pointer to next

+ self.feat_repo:next()

+ collectgarbage("collect")

+ return res

+end

+# This file was generated using the following command:

+# ./configure

+

+# Rules that enable valgrind debugging ("make valgrind")

+

+valgrind: .valgrind

+

+.valgrind:

+ echo -n > valgrind.out

+ for x in $(TESTFILES); do echo $$x>>valgrind.out; valgrind ./$$x >/dev/null 2>> valgrind.out; done

+ ! ( grep 'ERROR SUMMARY' valgrind.out | grep -v '0 errors' )

+ ! ( grep 'definitely lost' valgrind.out | grep -v -w 0 )

+ rm valgrind.out

+ touch .valgrind

+

+

+CONFIGURE_VERSION := 2

+OPENFSTLIBS = -L/slwork/users/wd007/src/kaldi/tools/openfst/lib -lfst

+OPENFSTLDFLAGS = -Wl,-rpath=/slwork/users/wd007/src/kaldi/tools/openfst/lib

+FSTROOT = /slwork/users/wd007/src/kaldi/tools/openfst

+ATLASINC = /slwork/users/wd007/src/kaldi/tools/ATLAS/include

+ATLASLIBS = -L/usr/lib -llapack -lcblas -latlas -lf77blas

+# You have to make sure ATLASLIBS is set...

+

+ifndef FSTROOT

+$(error FSTROOT not defined.)

+endif

+

+ifndef ATLASINC

+$(error ATLASINC not defined.)

+endif

+

+ifndef ATLASLIBS

+$(error ATLASLIBS not defined.)

+endif

+

+

+CXXFLAGS = -msse -msse2 -Wall -I.. \

+ -fPIC \

+ -DKALDI_DOUBLEPRECISION=0 -DHAVE_POSIX_MEMALIGN \

+ -Wno-sign-compare -Wno-unused-local-typedefs -Winit-self \

+ -DHAVE_EXECINFO_H=1 -rdynamic -DHAVE_CXXABI_H \

+ -DHAVE_ATLAS -I$(ATLASINC) \

+ -I$(FSTROOT)/include \

+ $(EXTRA_CXXFLAGS) \

+ -g # -O0 -DKALDI_PARANOID

+

+ifeq ($(KALDI_FLAVOR), dynamic)

+CXXFLAGS += -fPIC

+endif

+

+LDFLAGS = -rdynamic $(OPENFSTLDFLAGS)

+LDLIBS = $(EXTRA_LDLIBS) $(OPENFSTLIBS) $(ATLASLIBS) -lm -lpthread -ldl

+CC = g++

+CXX = g++

+AR = ar

+AS = as

+RANLIB = ranlib

+

+#Next section enables CUDA for compilation

+CUDA = true

+CUDATKDIR = /usr/local/cuda

+

+CUDA_INCLUDE= -I$(CUDATKDIR)/include

+CUDA_FLAGS = -g -Xcompiler -fPIC --verbose --machine 64 -DHAVE_CUDA

+

+CXXFLAGS += -DHAVE_CUDA -I$(CUDATKDIR)/include

+CUDA_LDFLAGS += -L$(CUDATKDIR)/lib64 -Wl,-rpath,$(CUDATKDIR)/lib64

+CUDA_LDLIBS += -lcublas -lcudart #LDLIBS : The libs are loaded later than static libs in implicit rule

+

+package = "kaldi_io"

+version = "scm-1"

+source = {

+ url = "https://github.com/Nerv-SJTU/nerv-speech.git"

+}

+description = {

+ summary = "Kaldi I/O support (Kaldi I/O wrapper) for Nerv",

+ detailed = [[

+ ]],

+ homepage = "https://github.com/Nerv-SJTU/nerv-speech",

+ license = "BSD"

+}

+dependencies = {

+ "nerv >= scm-1",

+ "lua >= 5.1"

+}

+build = {

+ type = "make",

+ build_variables = {

+ CFLAGS="$(CFLAGS)",

+ LIBFLAG="$(LIBFLAG)",

+ LUA_LIBDIR="$(LUA_LIBDIR)",

+ LUA_BINDIR="$(LUA_BINDIR)",

+ LUA_INCDIR="$(LUA_INCDIR)",

+ INST_PREFIX="$(PREFIX)",

+ LUA="$(LUA)",

+ },

+ install_variables = {

+ LUA_BINDIR="$(LUA_BINDIR)",

+ INST_PREFIX="$(PREFIX)",

+ INST_BINDIR="$(BINDIR)",

+ INST_LIBDIR="$(LIBDIR)",

+ INST_LUADIR="$(LUADIR)",

+ INST_CONFDIR="$(CONFDIR)",

+ },

+}

+#include <string>

+#include "kaldi/base/kaldi-common.h"

+#include "kaldi/hmm/posterior.h"

+#include "kaldi/util/table-types.h"

+typedef kaldi::BaseFloat BaseFloat;

+

+extern "C" {

+#include "cwrapper_kaldi.h"

+#include "string.h"

+#include "assert.h"

+#include "nerv/common.h"

+

+ extern Matrix *nerv_matrix_host_float_create(long nrow, long ncol, Status *status);

+ extern Matrix *nerv_matrix_host_double_create(long nrow, long ncol, Status *status);

+

+ struct KaldiFeatureRepo {

+ kaldi::SequentialBaseFloatMatrixReader* feature_reader;

+ string utt;

+ };

+

+ KaldiFeatureRepo *kaldi_feature_repo_new(const char *feature_rspecifier) {

+ KaldiFeatureRepo *repo = new KaldiFeatureRepo();

+ repo->feature_reader = new kaldi::SequentialBaseFloatMatrixReader(string(feature_rspecifier));

+ return repo;

+ }

+

+ Matrix *kaldi_feature_repo_read_utterance(KaldiFeatureRepo *repo, lua_State *L, int debug) {

+ Matrix *mat; /* nerv implementation */

+

+ repo->utt = repo->feature_reader->Key();

+ kaldi::Matrix<BaseFloat> kmat = repo->feature_reader->Value();

+

+ int n = kmat.NumRows();

+ int m = kmat.NumCols();

+ Status status;

+ assert(sizeof(BaseFloat) == sizeof(float));

+ if(sizeof(BaseFloat) == sizeof(float))

+ mat = nerv_matrix_host_float_create(n, m, &status);

+ else if(sizeof(BaseFloat) == sizeof(double))

+ mat = nerv_matrix_host_double_create(n, m, &status);

+ NERV_LUA_CHECK_STATUS(L, status);

+ size_t stride = mat->stride;

+ if (debug)

+ fprintf(stderr, "[kaldi] feature: %s %d %d\n", repo->utt.c_str(), n, m);

+

+ for (int i = 0; i < n; i++)

+ {

+ const BaseFloat *row = kmat.RowData(i);

+ BaseFloat *nerv_row = (BaseFloat *)((char *)mat->data.f + i * stride);

+ /* use memmove to copy the row, since KaldiLib uses compact storage */

+ memmove(nerv_row, row, sizeof(BaseFloat) * m);

+ }

+ return mat;

+ }

+

+ void kaldi_feature_repo_next(KaldiFeatureRepo *repo) {

+ repo->feature_reader->Next();

+ }

+

+ int kaldi_feature_repo_is_end(KaldiFeatureRepo *repo) {

+ return repo->feature_reader->Done();

+ }

+

+ void kaldi_feature_repo_destroy(KaldiFeatureRepo *repo) {

+ if (repo->feature_reader)

+ delete repo->feature_reader;

+ delete repo;

+ }

+

+ struct KaldiLabelRepo {

+ kaldi::RandomAccessPosteriorReader *targets_reader;

+ };

+

+ KaldiLabelRepo *kaldi_label_repo_new(const char *targets_rspecifier, const char *fmt) {

+ KaldiLabelRepo *repo = new KaldiLabelRepo();

+ repo->targets_reader = new kaldi::RandomAccessPosteriorReader(string(targets_rspecifier));

+ return repo;

+ }

+

+ Matrix *kaldi_label_repo_read_utterance(KaldiLabelRepo *repo, KaldiFeatureRepo *frepo, int frm_ext, int nframes,

+ lua_State *L,

+ int debug) {

+ Matrix *mat;

+ kaldi::Posterior targets = repo->targets_reader->Value(frepo->utt);

+

+ int n = targets.size() < nframes ? targets.size() : nframes;

+ int m = (int)targets[0].size();

+

+ Status status;

+ assert(sizeof(BaseFloat) == sizeof(float));

+ if(sizeof(BaseFloat) == sizeof(float))

+ mat = nerv_matrix_host_float_create(n, m, &status);

+ else if(sizeof(BaseFloat) == sizeof(double))

+ mat = nerv_matrix_host_double_create(n, m, &status);

+ NERV_LUA_CHECK_STATUS(L, status);

+ size_t stride = mat->stride;

+

+ if (debug)

+ fprintf(stderr, "[kaldi] label: %s %d %d\n", frepo->utt.c_str(), n, m);

+ for (int i = 0; i < n; i++)

+ for(int j = 0; j < m; j++)

+ *((BaseFloat *)((char *)mat->data.f + (i * stride + j))) = (BaseFloat)targets[i][j].first;

+ return mat;

+ }

+

+ void kaldi_label_repo_destroy(KaldiLabelRepo *repo) {

+ if(repo->targets_reader)

+ delete repo->targets_reader;

+ delete repo;

+ }

+}

+#ifndef NERV_kaldi_KALDI_IO_CWRAPPER

+#define NERV_kaldi_KALDI_IO_CWRAPPER

+#include "nerv/matrix/matrix.h"

+#include "nerv/common.h"

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+ typedef struct KaldiFeatureRepo KaldiFeatureRepo;

+

+ KaldiFeatureRepo *kaldi_feature_repo_new(const char *);

+ Matrix *kaldi_feature_repo_read_utterance(KaldiFeatureRepo *repo, lua_State *L, int debug);

+ void kaldi_feature_repo_next(KaldiFeatureRepo *repo);

+ int kaldi_feature_repo_is_end(KaldiFeatureRepo *repo);

+ void kaldi_feature_repo_destroy(KaldiFeatureRepo *repo);

+

+ typedef struct KaldiLabelRepo KaldiLabelRepo;

+

+ KaldiLabelRepo *kaldi_label_repo_new(const char *, const char *fmt);

+

+ Matrix *kaldi_label_repo_read_utterance(KaldiLabelRepo *repo, KaldiFeatureRepo *, int, int,

+ lua_State *L,

+ int debug);

+

+ void kaldi_label_repo_destroy(KaldiLabelRepo *repo);

+#ifdef __cplusplus

+}

+#endif

+#endif

+#include "nerv/common.h"

+#include "cwrapper_kaldi.h"

+#include <stdio.h>

+

+const char *nerv_kaldi_feat_repo_tname = "nerv.KaldiFeatureRepo";

+const char *nerv_kaldi_label_repo_tname = "nerv.KaldiLabelRepo";

+const char *nerv_matrix_host_float_tname = "nerv.MMatrixFloat";

+

+static int feat_repo_new(lua_State *L) {

+ const char *feature_rsepcifier = luaL_checkstring(L, 1);

+ KaldiFeatureRepo *repo = kaldi_feature_repo_new(feature_rsepcifier);

+ luaT_pushudata(L, repo, nerv_kaldi_feat_repo_tname);

+ return 1;

+}

+

+static int feat_repo_destroy(lua_State *L) {

+ KaldiFeatureRepo *repo = luaT_checkudata(L, 1, nerv_kaldi_feat_repo_tname);

+ kaldi_feature_repo_destroy(repo);

+ return 0;

+}

+

+static int feat_repo_current_utterance(lua_State *L) {

+ KaldiFeatureRepo *repo = luaT_checkudata(L, 1, nerv_kaldi_feat_repo_tname);

+ int debug;

+ if (!lua_isboolean(L, 2))

+ nerv_error(L, "debug flag should be a boolean");

+ debug = lua_toboolean(L, 2);

+ Matrix *utter = kaldi_feature_repo_read_utterance(repo, L, debug);

+ luaT_pushudata(L, utter, nerv_matrix_host_float_tname);

+ return 1;

+}

+

+static int feat_repo_next(lua_State *L) {

+ KaldiFeatureRepo *repo = luaT_checkudata(L, 1, nerv_kaldi_feat_repo_tname);

+ kaldi_feature_repo_next(repo);

+ return 0;

+}

+

+static int feat_repo_is_end(lua_State *L) {

+ KaldiFeatureRepo *repo = luaT_checkudata(L, 1, nerv_kaldi_feat_repo_tname);

+ lua_pushboolean(L, kaldi_feature_repo_is_end(repo));

+ return 1;

+}

+

+static const luaL_Reg feat_repo_methods[] = {

+ {"cur_utter", feat_repo_current_utterance},

+ {"next", feat_repo_next},

+ {"is_end", feat_repo_is_end},

+ {NULL, NULL}

+};

+

+static int label_repo_new(lua_State *L) {

+ const char *targets_rspecifier = luaL_checkstring(L, 1);

+ const char *fmt = luaL_checkstring(L, 2);

+ KaldiLabelRepo *repo = kaldi_label_repo_new(targets_rspecifier, fmt);

+ luaT_pushudata(L, repo, nerv_kaldi_label_repo_tname);

+ return 1;

+}

+

+static int label_repo_read_utterance(lua_State *L) {

+ KaldiLabelRepo *repo = luaT_checkudata(L, 1, nerv_kaldi_label_repo_tname);

+ KaldiFeatureRepo *feat_repo = luaT_checkudata(L, 2, nerv_kaldi_feat_repo_tname);

+ int frm_ext, nframes, debug;

+ if (!lua_isnumber(L, 3))

+ nerv_error(L, "frm_ext should be a number");

+ frm_ext = lua_tonumber(L, 3);

+ if (!lua_isnumber(L, 4))

+ nerv_error(L, "nframes should be a number");

+ nframes = lua_tonumber(L, 4);

+ if (!lua_isboolean(L, 5))

+ nerv_error(L, "debug flag should be a boolean");

+ debug = lua_toboolean(L, 5);

+ Matrix *utter = kaldi_label_repo_read_utterance(repo, feat_repo, frm_ext, nframes, L, debug);

+ luaT_pushudata(L, utter, nerv_matrix_host_float_tname);

+ return 1;

+}

+

+static int label_repo_destroy(lua_State *L) {

+ KaldiLabelRepo *repo = luaT_checkudata(L, 1, nerv_kaldi_label_repo_tname);

+ kaldi_label_repo_destroy(repo);

+ return 0;

+}

+

+static const luaL_Reg label_repo_methods[] = {

+ {"get_utter", label_repo_read_utterance},

+ {NULL, NULL}

+};

+

+static void feat_repo_init(lua_State *L) {

+ luaT_newmetatable(L, nerv_kaldi_feat_repo_tname, NULL,

+ feat_repo_new, feat_repo_destroy, NULL);

+ luaL_register(L, NULL, feat_repo_methods);

+ lua_pop(L, 1);

+}

+

+static void label_repo_init(lua_State *L) {

+ luaT_newmetatable(L, nerv_kaldi_label_repo_tname, NULL,

+ label_repo_new, label_repo_destroy, NULL);

+ luaL_register(L, NULL, label_repo_methods);

+ lua_pop(L, 1);

+}

+

+void kaldi_io_init(lua_State *L) {

+ feat_repo_init(L);

+ label_repo_init(L);

+}

+// base/io-funcs-inl.h

+

+// Copyright 2009-2011 Microsoft Corporation; Saarland University;

+// Jan Silovsky; Yanmin Qian; 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.

+

+#ifndef KALDI_BASE_IO_FUNCS_INL_H_

+#define KALDI_BASE_IO_FUNCS_INL_H_ 1

+

+// Do not include this file directly. It is included by base/io-funcs.h

+

+#include <limits>

+#include <vector>

+

+namespace kaldi {

+

+// Template that covers integers.

+template<class T> void WriteBasicType(std::ostream &os,

+ bool binary, T t) {

+ // Compile time assertion that this is not called with a wrong type.

+ KALDI_ASSERT_IS_INTEGER_TYPE(T);

+ if (binary) {

+ char len_c = (std::numeric_limits<T>::is_signed ? 1 : -1)

+ * static_cast<char>(sizeof(t));

+ os.put(len_c);

+ os.write(reinterpret_cast<const char *>(&t), sizeof(t));

+ } else {

+ if (sizeof(t) == 1)

+ os << static_cast<int16>(t) << " ";

+ else

+ os << t << " ";

+ }

+ if (os.fail()) {

+ throw std::runtime_error("Write failure in WriteBasicType.");

+ }

+}

+

+// Template that covers integers.

+template<class T> inline void ReadBasicType(std::istream &is,

+ bool binary, T *t) {

+ KALDI_PARANOID_ASSERT(t != NULL);

+ // Compile time assertion that this is not called with a wrong type.

+ KALDI_ASSERT_IS_INTEGER_TYPE(T);

+ if (binary) {

+ int len_c_in = is.get();

+ if (len_c_in == -1)

+ KALDI_ERR << "ReadBasicType: encountered end of stream.";

+ char len_c = static_cast<char>(len_c_in), len_c_expected

+ = (std::numeric_limits<T>::is_signed ? 1 : -1)

+ * static_cast<char>(sizeof(*t));

+

+ if (len_c != len_c_expected) {

+ KALDI_ERR << "ReadBasicType: did not get expected integer type, "

+ << static_cast<int>(len_c)

+ << " vs. " << static_cast<int>(len_c_expected)

+ << ". You can change this code to successfully"

+ << " read it later, if needed.";

+ // insert code here to read "wrong" type. Might have a switch statement.

+ }

+ is.read(reinterpret_cast<char *>(t), sizeof(*t));

+ } else {

+ if (sizeof(*t) == 1) {

+ int16 i;

+ is >> i;

+ *t = i;

+ } else {

+ is >> *t;

+ }

+ }

+ if (is.fail()) {

+ KALDI_ERR << "Read failure in ReadBasicType, file position is "

+ << is.tellg() << ", next char is " << is.peek();

+ }

+}

+

+

+template<class T> inline void WriteIntegerVector(std::ostream &os, bool binary,

+ const std::vector<T> &v) {

+ // Compile time assertion that this is not called with a wrong type.

+ KALDI_ASSERT_IS_INTEGER_TYPE(T);

+ if (binary) {

+ char sz = sizeof(T); // this is currently just a check.

+ os.write(&sz, 1);

+ int32 vecsz = static_cast<int32>(v.size());

+ KALDI_ASSERT((size_t)vecsz == v.size());

+ os.write(reinterpret_cast<const char *>(&vecsz), sizeof(vecsz));

+ if (vecsz != 0) {

+ os.write(reinterpret_cast<const char *>(&(v[0])), sizeof(T)*vecsz);

+ }

+ } else {

+ // focus here is on prettiness of text form rather than

+ // efficiency of reading-in.

+ // reading-in is dominated by low-level operations anyway:

+ // for efficiency use binary.

+ os << "[ ";

+ typename std::vector<T>::const_iterator iter = v.begin(), end = v.end();

+ for (; iter != end; ++iter) {

+ if (sizeof(T) == 1)

+ os << static_cast<int16>(*iter) << " ";

+ else

+ os << *iter << " ";

+ }

+ os << "]\n";

+ }

+ if (os.fail()) {

+ throw std::runtime_error("Write failure in WriteIntegerType.");

+ }

+}

+

+

+template<class T> inline void ReadIntegerVector(std::istream &is,

+ bool binary,

+ std::vector<T> *v) {

+ KALDI_ASSERT_IS_INTEGER_TYPE(T);

+ KALDI_ASSERT(v != NULL);

+ if (binary) {

+ int sz = is.peek();

+ if (sz == sizeof(T)) {

+ is.get();

+ } else { // this is currently just a check.

+ KALDI_ERR << "ReadIntegerVector: expected to see type of size "

+ << sizeof(T) << ", saw instead " << sz << ", at file position "

+ << is.tellg();

+ }

+ int32 vecsz;

+ is.read(reinterpret_cast<char *>(&vecsz), sizeof(vecsz));

+ if (is.fail() || vecsz < 0) goto bad;

+ v->resize(vecsz);

+ if (vecsz > 0) {

+ is.read(reinterpret_cast<char *>(&((*v)[0])), sizeof(T)*vecsz);

+ }

+ } else {

+ std::vector<T> tmp_v; // use temporary so v doesn't use extra memory

+ // due to resizing.

+ is >> std::ws;

+ if (is.peek() != static_cast<int>('[')) {

+ KALDI_ERR << "ReadIntegerVector: expected to see [, saw "

+ << is.peek() << ", at file position " << is.tellg();

+ }

+ is.get(); // consume the '['.

+ is >> std::ws; // consume whitespace.

+ while (is.peek() != static_cast<int>(']')) {

+ if (sizeof(T) == 1) { // read/write chars as numbers.

+ int16 next_t;

+ is >> next_t >> std::ws;

+ if (is.fail()) goto bad;

+ else

+ tmp_v.push_back((T)next_t);

+ } else {

+ T next_t;

+ is >> next_t >> std::ws;

+ if (is.fail()) goto bad;

+ else

+ tmp_v.push_back(next_t);

+ }

+ }

+ is.get(); // get the final ']'.

+ *v = tmp_v; // could use std::swap to use less temporary memory, but this

+ // uses less permanent memory.

+ }

+ if (!is.fail()) return;

+ bad:

+ KALDI_ERR << "ReadIntegerVector: read failure at file position "

+ << is.tellg();

+}

+

+// Initialize an opened stream for writing by writing an optional binary

+// header and modifying the floating-point precision.

+inline void InitKaldiOutputStream(std::ostream &os, bool binary) {

+ // This does not throw exceptions (does not check for errors).

+ if (binary) {

+ os.put('\0');

+ os.put('B');

+ }

+ // Note, in non-binary mode we may at some point want to mess with

+ // the precision a bit.

+ // 7 is a bit more than the precision of float..

+ if (os.precision() < 7)

+ os.precision(7);

+}

+

+/// Initialize an opened stream for reading by detecting the binary header and

+// setting the "binary" value appropriately.

+inline bool InitKaldiInputStream(std::istream &is, bool *binary) {

+ // Sets the 'binary' variable.

+ // Throws exception in the very unusual situation that stream

+ // starts with '\0' but not then 'B'.

+

+ if (is.peek() == '\0') { // seems to be binary

+ is.get();

+ if (is.peek() != 'B') {

+ return false;

+ }

+ is.get();

+ *binary = true;

+ return true;

+ } else {

+ *binary = false;

+ return true;

+ }

+}

+

+} // end namespace kaldi.

+

+#endif // KALDI_BASE_IO_FUNCS_INL_H_

+// base/io-funcs.h

+

+// Copyright 2009-2011 Microsoft Corporation; Saarland University;

+// Jan Silovsky; Yanmin Qian

+

+// 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.

+

+#ifndef KALDI_BASE_IO_FUNCS_H_

+#define KALDI_BASE_IO_FUNCS_H_

+

+// This header only contains some relatively low-level I/O functions.

+// The full Kaldi I/O declarations are in ../util/kaldi-io.h

+// and ../util/kaldi-table.h

+// They were put in util/ in order to avoid making the Matrix library

+// dependent on them.

+

+#include <cctype>

+#include <vector>

+#include <string>

+#include "base/kaldi-common.h"

+

+namespace kaldi {

+

+

+

+/*

+ This comment describes the Kaldi approach to I/O. All objects can be written

+ and read in two modes: binary and text. In addition we want to make the I/O

+ work if we redefine the typedef "BaseFloat" between floats and doubles.

+ We also want to have control over whitespace in text mode without affecting

+ the meaning of the file, for pretty-printing purposes.

+

+ Errors are handled by throwing an exception (std::runtime_error).

+

+ For integer and floating-point types (and boolean values):

+

+ WriteBasicType(std::ostream &, bool binary, const T&);

+ ReadBasicType(std::istream &, bool binary, T*);

+

+ and we expect these functions to be defined in such a way that they work when

+ the type T changes between float and double, so you can read float into double

+ and vice versa]. Note that for efficiency and space-saving reasons, the Vector

+ and Matrix classes do not use these functions [but they preserve the type

+ interchangeability in their own way]

+

+ For a class (or struct) C:

+ class C {

+ ..

+ Write(std::ostream &, bool binary, [possibly extra optional args for specific classes]) const;

+ Read(std::istream &, bool binary, [possibly extra optional args for specific classes]);

+ ..

+ }

+ NOTE: The only actual optional args we used are the "add" arguments in

+ Vector/Matrix classes, which specify whether we should sum the data already

+ in the class with the data being read.

+

+ For types which are typedef's involving stl classes, I/O is as follows:

+ typedef std::vector<std::pair<A, B> > MyTypedefName;

+

+ The user should define something like:

+

+ WriteMyTypedefName(std::ostream &, bool binary, const MyTypedefName &t);

+ ReadMyTypedefName(std::ostream &, bool binary, MyTypedefName *t);

+

+ The user would have to write these functions.

+

+ For a type std::vector<T>:

+

+ void WriteIntegerVector(std::ostream &os, bool binary, const std::vector<T> &v);

+ void ReadIntegerVector(std::istream &is, bool binary, std::vector<T> *v);

+

+ For other types, e.g. vectors of pairs, the user should create a routine of the

+ type WriteMyTypedefName. This is to avoid introducing confusing templated functions;

+ we could easily create templated functions to handle most of these cases but they

+ would have to share the same name.

+

+ It also often happens that the user needs to write/read special tokens as part

+ of a file. These might be class headers, or separators/identifiers in the class.

+ We provide special functions for manipulating these. These special tokens must

+ be nonempty and must not contain any whitespace.

+

+ void WriteToken(std::ostream &os, bool binary, const char*);

+ void WriteToken(std::ostream &os, bool binary, const std::string & token);

+ int Peek(std::istream &is, bool binary);

+ void ReadToken(std::istream &is, bool binary, std::string *str);

+ void PeekToken(std::istream &is, bool binary, std::string *str);

+

+

+ WriteToken writes the token and one space (whether in binary or text mode).

+

+ Peek returns the first character of the next token, by consuming whitespace

+ (in text mode) and then returning the peek() character. It returns -1 at EOF;

+ it doesn't throw. It's useful if a class can have various forms based on

+ typedefs and virtual classes, and wants to know which version to read.

+

+ ReadToken allow the caller to obtain the next token. PeekToken works just

+ like ReadToken, but seeks back to the beginning of the token. A subsequent

+ call to ReadToken will read the same token again. This is useful when

+ different object types are written to the same file; using PeekToken one can

+ decide which of the objects to read.

+

+ There is currently no special functionality for writing/reading strings (where the strings

+ contain data rather than "special tokens" that are whitespace-free and nonempty). This is

+ because Kaldi is structured in such a way that strings don't appear, except as OpenFst symbol

+ table entries (and these have their own format).

+

+

+ NOTE: you should not call ReadIntegerType and WriteIntegerType with types,

+ such as int and size_t, that are machine-independent -- at least not

+ if you want your file formats to port between machines. Use int32 and

+ int64 where necessary. There is no way to detect this using compile-time

+ assertions because C++ only keeps track of the internal representation of

+ the type.

+*/

+

+/// \addtogroup io_funcs_basic

+/// @{

+

+

+/// WriteBasicType is the name of the write function for bool, integer types,

+/// and floating-point types. They all throw on error.

+template<class T> void WriteBasicType(std::ostream &os, bool binary, T t);

+

+/// ReadBasicType is the name of the read function for bool, integer types,

+/// and floating-point types. They all throw on error.

+template<class T> void ReadBasicType(std::istream &is, bool binary, T *t);

+

+

+// Declare specialization for bool.

+template<>

+void WriteBasicType<bool>(std::ostream &os, bool binary, bool b);

+

+template <>

+void ReadBasicType<bool>(std::istream &is, bool binary, bool *b);

+

+// Declare specializations for float and double.

+template<>

+void WriteBasicType<float>(std::ostream &os, bool binary, float f);

+

+template<>

+void WriteBasicType<double>(std::ostream &os, bool binary, double f);

+

+template<>

+void ReadBasicType<float>(std::istream &is, bool binary, float *f);

+

+template<>

+void ReadBasicType<double>(std::istream &is, bool binary, double *f);

+

+// Define ReadBasicType that accepts an "add" parameter to add to

+// the destination. Caution: if used in Read functions, be careful

+// to initialize the parameters concerned to zero in the default

+// constructor.

+template<class T>

+inline void ReadBasicType(std::istream &is, bool binary, T *t, bool add) {

+ if (!add) {

+ ReadBasicType(is, binary, t);

+ } else {

+ T tmp = T(0);

+ ReadBasicType(is, binary, &tmp);

+ *t += tmp;

+ }

+}

+

+/// Function for writing STL vectors of integer types.

+template<class T> inline void WriteIntegerVector(std::ostream &os, bool binary,

+ const std::vector<T> &v);

+

+/// Function for reading STL vector of integer types.

+template<class T> inline void ReadIntegerVector(std::istream &is, bool binary,

+ std::vector<T> *v);

+

+/// The WriteToken functions are for writing nonempty sequences of non-space

+/// characters. They are not for general strings.

+void WriteToken(std::ostream &os, bool binary, const char *token);

+void WriteToken(std::ostream &os, bool binary, const std::string & token);

+

+/// Peek consumes whitespace (if binary == false) and then returns the peek()

+/// value of the stream.

+int Peek(std::istream &is, bool binary);

+

+/// ReadToken gets the next token and puts it in str (exception on failure).

+void ReadToken(std::istream &is, bool binary, std::string *token);

+

+/// PeekToken will return the first character of the next token, or -1 if end of

+/// file. It's the same as Peek(), except if the first character is '<' it will

+/// skip over it and will return the next character. It will unget the '<' so

+/// the stream is where it was before you did PeekToken().

+int PeekToken(std::istream &is, bool binary);

+

+/// ExpectToken tries to read in the given token, and throws an exception

+/// on failure.

+void ExpectToken(std::istream &is, bool binary, const char *token);

+void ExpectToken(std::istream &is, bool binary, const std::string & token);

+

+/// ExpectPretty attempts to read the text in "token", but only in non-binary

+/// mode. Throws exception on failure. It expects an exact match except that

+/// arbitrary whitespace matches arbitrary whitespace.

+void ExpectPretty(std::istream &is, bool binary, const char *token);

+void ExpectPretty(std::istream &is, bool binary, const std::string & token);

+

+/// @} end "addtogroup io_funcs_basic"

+

+

+/// InitKaldiOutputStream initializes an opened stream for writing by writing an

+/// optional binary header and modifying the floating-point precision; it will

+/// typically not be called by users directly.

+inline void InitKaldiOutputStream(std::ostream &os, bool binary);

+

+/// InitKaldiInputStream initializes an opened stream for reading by detecting

+/// the binary header and setting the "binary" value appropriately;

+/// It will typically not be called by users directly.

+inline bool InitKaldiInputStream(std::istream &is, bool *binary);

+

+} // end namespace kaldi.

+

+#include "base/io-funcs-inl.h"

+

+#endif // KALDI_BASE_IO_FUNCS_H_

+// base/kaldi-common.h

+

+// Copyright 2009-2011 Microsoft Corporation

+

+// 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.

+

+#ifndef KALDI_BASE_KALDI_COMMON_H_

+#define KALDI_BASE_KALDI_COMMON_H_ 1

+

+#include <cstddef>

+#include <cstdlib>

+#include <cstring> // C string stuff like strcpy

+#include <string>

+#include <sstream>

+#include <stdexcept>

+#include <cassert>

+#include <vector>

+#include <iostream>

+#include <fstream>

+

+#include "base/kaldi-utils.h"

+#include "base/kaldi-error.h"

+#include "base/kaldi-types.h"

+#include "base/io-funcs.h"

+#include "base/kaldi-math.h"

+

+#endif // KALDI_BASE_KALDI_COMMON_H_

+

+// base/kaldi-error.h

+

+// Copyright 2009-2011 Microsoft Corporation; Ondrej Glembek; Lukas Burget;

+// Saarland University

+

+// 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.

+

+#ifndef KALDI_BASE_KALDI_ERROR_H_

+#define KALDI_BASE_KALDI_ERROR_H_ 1

+

+#include <stdexcept>

+#include <string>

+#include <cstring>

+#include <sstream>

+#include <cstdio>

+

+#ifdef _MSC_VER

+#define NOEXCEPT(Predicate)

+#elif __cplusplus > 199711L || defined(__GXX_EXPERIMENTAL_CXX0X__)

+#define NOEXCEPT(Predicate) noexcept((Predicate))

+#else

+#define NOEXCEPT(Predicate)

+#endif

+

+#include "base/kaldi-types.h"

+#include "base/kaldi-utils.h"

+

+/* Important that this file does not depend on any other kaldi headers. */

+

+

+namespace kaldi {

+

+/// \addtogroup error_group

+/// @{

+

+/// This is set by util/parse-options.{h, cc} if you set --verbose = ? option

+extern int32 g_kaldi_verbose_level;

+

+/// This is set by util/parse-options.{h, cc} (from argv[0]) and used (if set)

+/// in error reporting code to display the name of the program (this is because

+/// in our scripts, we often mix together the stderr of many programs). it is

+/// the base-name of the program (no directory), followed by ':' We don't use

+/// std::string, due to the static initialization order fiasco.

+extern const char *g_program_name;

+

+inline int32 GetVerboseLevel() { return g_kaldi_verbose_level; }

+

+/// This should be rarely used; command-line programs set the verbose level

+/// automatically from ParseOptions.

+inline void SetVerboseLevel(int32 i) { g_kaldi_verbose_level = i; }

+

+// Class KaldiLogMessage is invoked from the KALDI_WARN, KALDI_VLOG and

+// KALDI_LOG macros. It prints the message to stderr. Note: we avoid

+// using cerr, due to problems with thread safety. fprintf is guaranteed

+// thread-safe.

+

+// class KaldiWarnMessage is invoked from the KALDI_WARN macro.

+class KaldiWarnMessage {

+ public:

+ inline std::ostream &stream() { return ss; }

+ KaldiWarnMessage(const char *func, const char *file, int32 line);

+ ~KaldiWarnMessage() { fprintf(stderr, "%s\n", ss.str().c_str()); }

+ private:

+ std::ostringstream ss;

+};

+

+// class KaldiLogMessage is invoked from the KALDI_LOG macro.

+class KaldiLogMessage {

+ public:

+ inline std::ostream &stream() { return ss; }

+ KaldiLogMessage(const char *func, const char *file, int32 line);

+ ~KaldiLogMessage() { fprintf(stderr, "%s\n", ss.str().c_str()); }

+ private:

+ std::ostringstream ss;

+};

+

+// Class KaldiVlogMessage is invoked from the KALDI_VLOG macro.

+class KaldiVlogMessage {

+ public:

+ KaldiVlogMessage(const char *func, const char *file, int32 line,

+ int32 verbose_level);

+ inline std::ostream &stream() { return ss; }

+ ~KaldiVlogMessage() { fprintf(stderr, "%s\n", ss.str().c_str()); }

+ private:

+ std::ostringstream ss;

+};

+

+

+// class KaldiErrorMessage is invoked from the KALDI_ERROR macro.

+// The destructor throws an exception.

+class KaldiErrorMessage {

+ public:

+ KaldiErrorMessage(const char *func, const char *file, int32 line);

+ inline std::ostream &stream() { return ss; }

+ ~KaldiErrorMessage() NOEXCEPT(false); // defined in kaldi-error.cc

+ private:

+ std::ostringstream ss;

+};

+

+

+

+#ifdef _MSC_VER

+#define __func__ __FUNCTION__

+#endif

+

+#ifndef NDEBUG

+#define KALDI_ASSERT(cond) \

+ if (!(cond)) kaldi::KaldiAssertFailure_(__func__, __FILE__, __LINE__, #cond);

+#else

+#define KALDI_ASSERT(cond)

+#endif

+// also see KALDI_COMPILE_TIME_ASSERT, defined in base/kaldi-utils.h,

+// and KALDI_ASSERT_IS_INTEGER_TYPE and KALDI_ASSERT_IS_FLOATING_TYPE,

+// also defined there.

+#ifdef KALDI_PARANOID // some more expensive asserts only checked if this defined

+#define KALDI_PARANOID_ASSERT(cond) \

+ if (!(cond)) kaldi::KaldiAssertFailure_(__func__, __FILE__, __LINE__, #cond);

+#else

+#define KALDI_PARANOID_ASSERT(cond)

+#endif

+

+#define KALDI_ERR kaldi::KaldiErrorMessage(__func__, __FILE__, __LINE__).stream()

+#define KALDI_WARN kaldi::KaldiWarnMessage(__func__, __FILE__, __LINE__).stream()

+#define KALDI_LOG kaldi::KaldiLogMessage(__func__, __FILE__, __LINE__).stream()

+

+#define KALDI_VLOG(v) if (v <= kaldi::g_kaldi_verbose_level) \

+ kaldi::KaldiVlogMessage(__func__, __FILE__, __LINE__, v).stream()

+

+inline bool IsKaldiError(const std::string &str) {

+ return(!strncmp(str.c_str(), "ERROR ", 6));

+}

+

+void KaldiAssertFailure_(const char *func, const char *file,

+ int32 line, const char *cond_str);

+

+/// @} end "addtogroup error_group"

+

+} // namespace kaldi

+

+#endif // KALDI_BASE_KALDI_ERROR_H_

+// base/kaldi-math.h

+

+// Copyright 2009-2011 Ondrej Glembek; Microsoft Corporation; Yanmin Qian;

+// Jan Silovsky; Saarland University

+//

+// 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.

+

+#ifndef KALDI_BASE_KALDI_MATH_H_

+#define KALDI_BASE_KALDI_MATH_H_ 1

+

+#ifdef _MSC_VER

+#include <float.h>

+#endif

+

+#include <cmath>

+#include <limits>

+#include <vector>

+

+#include "base/kaldi-types.h"

+#include "base/kaldi-common.h"

+

+

+#ifndef DBL_EPSILON

+#define DBL_EPSILON 2.2204460492503131e-16

+#endif

+#ifndef FLT_EPSILON

+#define FLT_EPSILON 1.19209290e-7f

+#endif

+

+#ifndef M_PI

+# define M_PI 3.1415926535897932384626433832795

+#endif

+

+#ifndef M_SQRT2

+# define M_SQRT2 1.4142135623730950488016887

+#endif

+

+

+#ifndef M_2PI

+# define M_2PI 6.283185307179586476925286766559005

+#endif

+

+#ifndef M_SQRT1_2

+# define M_SQRT1_2 0.7071067811865475244008443621048490

+#endif

+

+#ifndef M_LOG_2PI

+#define M_LOG_2PI 1.8378770664093454835606594728112

+#endif

+

+#ifndef M_LN2

+#define M_LN2 0.693147180559945309417232121458

+#endif

+

+#ifdef _MSC_VER

+# define KALDI_ISNAN _isnan

+# define KALDI_ISINF(x) (!_isnan(x) && _isnan(x-x))

+# define KALDI_ISFINITE _finite

+#else

+# define KALDI_ISNAN std::isnan

+# define KALDI_ISINF std::isinf

+# define KALDI_ISFINITE(x) std::isfinite(x)

+#endif

+#if !defined(KALDI_SQR)

+# define KALDI_SQR(x) ((x) * (x))

+#endif

+

+namespace kaldi {

+

+// -infinity

+const float kLogZeroFloat = -std::numeric_limits<float>::infinity();

+const double kLogZeroDouble = -std::numeric_limits<double>::infinity();

+const BaseFloat kLogZeroBaseFloat = -std::numeric_limits<BaseFloat>::infinity();

+

+// Returns a random integer between 0 and RAND_MAX, inclusive

+int Rand(struct RandomState* state=NULL);

+

+// State for thread-safe random number generator

+struct RandomState {

+ RandomState();

+ unsigned seed;

+};

+

+// Returns a random integer between min and max inclusive.

+int32 RandInt(int32 min, int32 max, struct RandomState* state=NULL);

+

+bool WithProb(BaseFloat prob, struct RandomState* state=NULL); // Returns true with probability "prob",

+// with 0 <= prob <= 1 [we check this].

+// Internally calls Rand(). This function is carefully implemented so

+// that it should work even if prob is very small.

+

+/// Returns a random number strictly between 0 and 1.

+inline float RandUniform(struct RandomState* state = NULL) {

+ return static_cast<float>((Rand(state) + 1.0) / (RAND_MAX+2.0));

+}

+

+inline float RandGauss(struct RandomState* state = NULL) {

+ return static_cast<float>(sqrtf (-2 * logf(RandUniform(state)))

+ * cosf(2*M_PI*RandUniform(state)));

+}

+

+// Returns poisson-distributed random number. Uses Knuth's algorithm.

+// Take care: this takes time proportinal

+// to lambda. Faster algorithms exist but are more complex.

+int32 RandPoisson(float lambda, struct RandomState* state=NULL);

+

+// Returns a pair of gaussian random numbers. Uses Box-Muller transform

+void RandGauss2(float *a, float *b, RandomState *state = NULL);

+void RandGauss2(double *a, double *b, RandomState *state = NULL);

+

+// Also see Vector<float,double>::RandCategorical().

+

+// This is a randomized pruning mechanism that preserves expectations,

+// that we typically use to prune posteriors.

+template<class Float>

+inline Float RandPrune(Float post, BaseFloat prune_thresh, struct RandomState* state=NULL) {

+ KALDI_ASSERT(prune_thresh >= 0.0);

+ if (post == 0.0 || std::abs(post) >= prune_thresh)

+ return post;

+ return (post >= 0 ? 1.0 : -1.0) *

+ (RandUniform(state) <= fabs(post)/prune_thresh ? prune_thresh : 0.0);

+}

+

+static const double kMinLogDiffDouble = std::log(DBL_EPSILON); // negative!

+static const float kMinLogDiffFloat = std::log(FLT_EPSILON); // negative!

+

+inline double LogAdd(double x, double y) {

+ double diff;

+ if (x < y) {

+ diff = x - y;

+ x = y;

+ } else {

+ diff = y - x;

+ }

+ // diff is negative. x is now the larger one.

+

+ if (diff >= kMinLogDiffDouble) {

+ double res;

+#ifdef _MSC_VER

+ res = x + log(1.0 + exp(diff));

+#else

+ res = x + log1p(exp(diff));

+#endif

+ return res;

+ } else {

+ return x; // return the larger one.

+ }

+}

+

+

+inline float LogAdd(float x, float y) {

+ float diff;

+ if (x < y) {

+ diff = x - y;

+ x = y;

+ } else {

+ diff = y - x;

+ }

+ // diff is negative. x is now the larger one.

+

+ if (diff >= kMinLogDiffFloat) {

+ float res;

+#ifdef _MSC_VER

+ res = x + logf(1.0 + expf(diff));

+#else

+ res = x + log1pf(expf(diff));

+#endif

+ return res;

+ } else {

+ return x; // return the larger one.

+ }

+}

+

+

+// returns exp(x) - exp(y).

+inline double LogSub(double x, double y) {

+ if (y >= x) { // Throws exception if y>=x.

+ if (y == x)

+ return kLogZeroDouble;

+ else

+ KALDI_ERR << "Cannot subtract a larger from a smaller number.";

+ }

+

+ double diff = y - x; // Will be negative.

+ double res = x + log(1.0 - exp(diff));

+

+ // res might be NAN if diff ~0.0, and 1.0-exp(diff) == 0 to machine precision

+ if (KALDI_ISNAN(res))

+ return kLogZeroDouble;

+ return res;

+}

+

+

+// returns exp(x) - exp(y).

+inline float LogSub(float x, float y) {

+ if (y >= x) { // Throws exception if y>=x.

+ if (y == x)

+ return kLogZeroDouble;

+ else

+ KALDI_ERR << "Cannot subtract a larger from a smaller number.";

+ }

+

+ float diff = y - x; // Will be negative.

+ float res = x + logf(1.0 - expf(diff));

+

+ // res might be NAN if diff ~0.0, and 1.0-exp(diff) == 0 to machine precision

+ if (KALDI_ISNAN(res))

+ return kLogZeroFloat;

+ return res;

+}

+

+/// return abs(a - b) <= relative_tolerance * (abs(a)+abs(b)).

+static inline bool ApproxEqual(float a, float b,

+ float relative_tolerance = 0.001) {

+ // a==b handles infinities.

+ if (a==b) return true;

+ float diff = std::abs(a-b);

+ if (diff == std::numeric_limits<float>::infinity()

+ || diff != diff) return false; // diff is +inf or nan.

+ return (diff <= relative_tolerance*(std::abs(a)+std::abs(b)));

+}

+

+/// assert abs(a - b) <= relative_tolerance * (abs(a)+abs(b))

+static inline void AssertEqual(float a, float b,

+ float relative_tolerance = 0.001) {

+ // a==b handles infinities.

+ KALDI_ASSERT(ApproxEqual(a, b, relative_tolerance));

+}

+

+

+// RoundUpToNearestPowerOfTwo does the obvious thing. It crashes if n <= 0.

+int32 RoundUpToNearestPowerOfTwo(int32 n);

+

+template<class I> I Gcd(I m, I n) {

+ if (m == 0 || n == 0) {

+ if (m == 0 && n == 0) { // gcd not defined, as all integers are divisors.

+ KALDI_ERR << "Undefined GCD since m = 0, n = 0.";

+ }

+ return (m == 0 ? (n > 0 ? n : -n) : ( m > 0 ? m : -m));

+ // return absolute value of whichever is nonzero

+ }

+ // could use compile-time assertion

+ // but involves messing with complex template stuff.

+ KALDI_ASSERT(std::numeric_limits<I>::is_integer);

+ while (1) {

+ m %= n;

+ if (m == 0) return (n > 0 ? n : -n);

+ n %= m;

+ if (n == 0) return (m > 0 ? m : -m);

+ }

+}

+

+/// Returns the least common multiple of two integers. Will

+/// crash unless the inputs are positive.

+template<class I> I Lcm(I m, I n) {

+ KALDI_ASSERT(m > 0 && n > 0);

+ I gcd = Gcd(m, n);

+ return gcd * (m/gcd) * (n/gcd);

+}

+

+

+template<class I> void Factorize(I m, std::vector<I> *factors) {

+ // Splits a number into its prime factors, in sorted order from

+ // least to greatest, with duplication. A very inefficient

+ // algorithm, which is mainly intended for use in the

+ // mixed-radix FFT computation (where we assume most factors

+ // are small).

+ KALDI_ASSERT(factors != NULL);

+ KALDI_ASSERT(m >= 1); // Doesn't work for zero or negative numbers.

+ factors->clear();

+ I small_factors[10] = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29 };

+

+ // First try small factors.

+ for (I i = 0; i < 10; i++) {

+ if (m == 1) return; // We're done.

+ while (m % small_factors[i] == 0) {

+ m /= small_factors[i];

+ factors->push_back(small_factors[i]);

+ }

+ }

+ // Next try all odd numbers starting from 31.

+ for (I j = 31;; j += 2) {

+ if (m == 1) return;

+ while (m % j == 0) {

+ m /= j;

+ factors->push_back(j);

+ }

+ }

+}

+

+inline double Hypot(double x, double y) { return hypot(x, y); }

+

+inline float Hypot(float x, float y) { return hypotf(x, y); }

+

+#if !defined(_MSC_VER) || (_MSC_VER >= 1800)

+inline double Log1p(double x) { return log1p(x); }

+

+inline float Log1p(float x) { return log1pf(x); }

+#else

+inline double Log1p(double x) {

+ const double cutoff = 1.0e-08;

+ if (x < cutoff)

+ return x - 2 * x * x;

+ else

+ return log(1.0 + x);

+}

+

+inline float Log1p(float x) {

+ const float cutoff = 1.0e-07;

+ if (x < cutoff)

+ return x - 2 * x * x;

+ else

+ return log(1.0 + x);

+}

+#endif

+

+inline double Exp(double x) { return exp(x); }

+

+#ifndef KALDI_NO_EXPF

+inline float Exp(float x) { return expf(x); }

+#else

+inline float Exp(float x) { return exp(x); }

+#endif

+

+inline double Log(double x) { return log(x); }

+

+inline float Log(float x) { return logf(x); }

+

+

+} // namespace kaldi

+

+

+#endif // KALDI_BASE_KALDI_MATH_H_

+// base/kaldi-types.h

+

+// Copyright 2009-2011 Microsoft Corporation; Saarland University;

+// Jan Silovsky; Yanmin Qian

+

+// 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.

+

+#ifndef KALDI_BASE_KALDI_TYPES_H_

+#define KALDI_BASE_KALDI_TYPES_H_ 1

+

+namespace kaldi {

+// TYPEDEFS ..................................................................

+#if (KALDI_DOUBLEPRECISION != 0)

+typedef double BaseFloat;

+#else

+typedef float BaseFloat;

+#endif

+}

+

+#ifdef _MSC_VER

+namespace kaldi {

+typedef unsigned __int16 uint16;

+typedef unsigned __int32 uint32;

+typedef __int16 int16;

+typedef __int32 int32;

+typedef __int64 int64;

+typedef unsigned __int64 uint64;

+typedef float float32;

+typedef double double64;

+}

+#include <basetsd.h>

+#define ssize_t SSIZE_T

+

+#else

+// we can do this a different way if some platform

+// we find in the future lacks stdint.h

+#include <stdint.h>

+

+namespace kaldi {

+typedef uint16_t uint16;

+typedef uint32_t uint32;

+typedef uint64_t uint64;

+typedef int16_t int16;

+typedef int32_t int32;

+typedef int64_t int64;

+typedef float float32;

+typedef double double64;

+} // end namespace kaldi

+#endif

+

+#endif // KALDI_BASE_KALDI_TYPES_H_

+// base/kaldi-utils.h

+

+// Copyright 2009-2011 Ondrej Glembek; Microsoft Corporation;

+// Saarland University; Karel Vesely; Yanmin Qian

+

+// 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.

+

+#ifndef KALDI_BASE_KALDI_UTILS_H_

+#define KALDI_BASE_KALDI_UTILS_H_ 1

+

+#include <limits>

+#include <string>

+

+#if defined(_MSC_VER)

+# define WIN32_LEAN_AND_MEAN

+# define NOMINMAX

+# include <windows.h>

+#endif

+

+#if defined(_MSC_VER)

+#pragma warning(disable: 4244 4056 4305 4800 4267 4996 4756 4661)

+#define __restrict__

+#endif

+

+#ifdef HAVE_POSIX_MEMALIGN

+# define KALDI_MEMALIGN(align, size, pp_orig) \

+ (!posix_memalign(pp_orig, align, size) ? *(pp_orig) : NULL)

+# define KALDI_MEMALIGN_FREE(x) free(x)

+#elif defined(HAVE_MEMALIGN)

+ /* Some systems have memalign() but no declaration for it */

+ void * memalign(size_t align, size_t size);

+# define KALDI_MEMALIGN(align, size, pp_orig) \

+ (*(pp_orig) = memalign(align, size))

+# define KALDI_MEMALIGN_FREE(x) free(x)

+#elif defined(_MSC_VER)

+# define KALDI_MEMALIGN(align, size, pp_orig) \

+ (*(pp_orig) = _aligned_malloc(size, align))

+# define KALDI_MEMALIGN_FREE(x) _aligned_free(x)

+#else

+#error Manual memory alignment is no longer supported

+#endif

+

+#ifdef __ICC

+#pragma warning(disable: 383) // ICPC remark we don't want.

+#pragma warning(disable: 810) // ICPC remark we don't want.

+#pragma warning(disable: 981) // ICPC remark we don't want.

+#pragma warning(disable: 1418) // ICPC remark we don't want.

+#pragma warning(disable: 444) // ICPC remark we don't want.

+#pragma warning(disable: 869) // ICPC remark we don't want.

+#pragma warning(disable: 1287) // ICPC remark we don't want.

+#pragma warning(disable: 279) // ICPC remark we don't want.

+#pragma warning(disable: 981) // ICPC remark we don't want.

+#endif

+

+

+namespace kaldi {

+

+

+// CharToString prints the character in a human-readable form, for debugging.

+std::string CharToString(const char &c);

+

+

+inline int MachineIsLittleEndian() {

+ int check = 1;

+ return (*reinterpret_cast<char*>(&check) != 0);

+}

+

+// This function kaldi::Sleep() provides a portable way to sleep for a possibly fractional

+// number of seconds. On Windows it's only accurate to microseconds.

+void Sleep(float seconds);

+

+}

+

+#define KALDI_SWAP8(a) { \

+ int t = ((char*)&a)[0]; ((char*)&a)[0]=((char*)&a)[7]; ((char*)&a)[7]=t;\

+ t = ((char*)&a)[1]; ((char*)&a)[1]=((char*)&a)[6]; ((char*)&a)[6]=t;\

+ t = ((char*)&a)[2]; ((char*)&a)[2]=((char*)&a)[5]; ((char*)&a)[5]=t;\

+ t = ((char*)&a)[3]; ((char*)&a)[3]=((char*)&a)[4]; ((char*)&a)[4]=t;}

+#define KALDI_SWAP4(a) { \

+ int t = ((char*)&a)[0]; ((char*)&a)[0]=((char*)&a)[3]; ((char*)&a)[3]=t;\

+ t = ((char*)&a)[1]; ((char*)&a)[1]=((char*)&a)[2]; ((char*)&a)[2]=t;}

+#define KALDI_SWAP2(a) { \

+ int t = ((char*)&a)[0]; ((char*)&a)[0]=((char*)&a)[1]; ((char*)&a)[1]=t;}

+

+

+// Makes copy constructor and operator= private. Same as in compat.h of OpenFst

+// toolkit. If using VS, for which this results in compilation errors, we

+// do it differently.

+

+#if defined(_MSC_VER)

+#define KALDI_DISALLOW_COPY_AND_ASSIGN(type) \

+ void operator = (const type&)

+#else

+#define KALDI_DISALLOW_COPY_AND_ASSIGN(type) \

+ type(const type&); \

+ void operator = (const type&)

+#endif

+

+template<bool B> class KaldiCompileTimeAssert { };

+template<> class KaldiCompileTimeAssert<true> {

+ public:

+ static inline void Check() { }

+};

+

+#define KALDI_COMPILE_TIME_ASSERT(b) KaldiCompileTimeAssert<(b)>::Check()

+

+#define KALDI_ASSERT_IS_INTEGER_TYPE(I) \

+ KaldiCompileTimeAssert<std::numeric_limits<I>::is_specialized \

+ && std::numeric_limits<I>::is_integer>::Check()

+

+#define KALDI_ASSERT_IS_FLOATING_TYPE(F) \

+ KaldiCompileTimeAssert<std::numeric_limits<F>::is_specialized \

+ && !std::numeric_limits<F>::is_integer>::Check()

+

+#ifdef _MSC_VER

+#include <stdio.h>

+#define unlink _unlink

+#else

+#include <unistd.h>

+#endif

+

+

+#ifdef _MSC_VER

+#define KALDI_STRCASECMP _stricmp

+#else

+#define KALDI_STRCASECMP strcasecmp

+#endif

+#ifdef _MSC_VER

+# define KALDI_STRTOLL(cur_cstr, end_cstr) _strtoi64(cur_cstr, end_cstr, 10);

+#else

+# define KALDI_STRTOLL(cur_cstr, end_cstr) strtoll(cur_cstr, end_cstr, 10);

+#endif

+

+#define KALDI_STRTOD(cur_cstr, end_cstr) strtod(cur_cstr, end_cstr)

+

+#ifdef _MSC_VER

+# define KALDI_STRTOF(cur_cstr, end_cstr) \

+ static_cast<float>(strtod(cur_cstr, end_cstr));

+#else

+# define KALDI_STRTOF(cur_cstr, end_cstr) strtof(cur_cstr, end_cstr);

+#endif

+

+#endif // KALDI_BASE_KALDI_UTILS_H_

+

+// base/timer.h

+

+// Copyright 2009-2011 Ondrej Glembek; Microsoft Corporation

+

+// 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.

+#ifndef KALDI_BASE_TIMER_H_

+#define KALDI_BASE_TIMER_H_

+

+#include "base/kaldi-utils.h"

+// Note: Sleep(float secs) is included in base/kaldi-utils.h.

+

+

+#if defined(_MSC_VER) || defined(MINGW)

+

+namespace kaldi

+{

+

+class Timer {

+ public:

+ Timer() { Reset(); }

+ void Reset() {

+ QueryPerformanceCounter(&time_start_);

+ }

+ double Elapsed() {

+ LARGE_INTEGER time_end;

+ LARGE_INTEGER freq;

+ QueryPerformanceCounter(&time_end);

+ if (QueryPerformanceFrequency(&freq) == 0) return 0.0; // Hardware does not support this.

+ return ((double)time_end.QuadPart - (double)time_start_.QuadPart) /

+ ((double)freq.QuadPart);

+ }

+ private:

+ LARGE_INTEGER time_start_;

+};

+}

+

+#else

+

+# include <sys/time.h>

+# include <unistd.h>

+namespace kaldi

+{

+class Timer

+{

+ public:

+ Timer() { Reset(); }

+

+ void Reset() { gettimeofday(&this->time_start_, &time_zone_); }

+

+ /// Returns time in seconds.

+ double Elapsed() {

+ struct timeval time_end;

+ gettimeofday(&time_end, &time_zone_);

+ double t1, t2;

+ t1 = (double)time_start_.tv_sec +

+ (double)time_start_.tv_usec/(1000*1000);

+ t2 = (double)time_end.tv_sec + (double)time_end.tv_usec/(1000*1000);

+ return t2-t1;

+ }

+

+ private:

+ struct timeval time_start_;

+ struct timezone time_zone_;

+};

+}

+

+#endif

+

+

+#endif

+// hmm/hmm-topology.h

+

+// Copyright 2009-2011 Microsoft Corporation

+

+// 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.

+

+#ifndef KALDI_HMM_HMM_TOPOLOGY_H_

+#define KALDI_HMM_HMM_TOPOLOGY_H_

+

+#include "base/kaldi-common.h"

+#include "tree/context-dep.h"

+#include "util/const-integer-set.h"

+

+

+namespace kaldi {

+

+

+/// \addtogroup hmm_group

+/// @{

+

+/*

+ // The following would be the text form for the "normal" HMM topology.

+ // Note that the first state is the start state, and the final state,

+ // which must have no output transitions and must be nonemitting, has

+ // an exit probability of one (no other state can have nonzero exit

+ // probability; you can treat the transition probability to the final

+ // state as an exit probability).

+ // Note also that it's valid to omit the "<PdfClass>" entry of the <State>, which

+ // will mean we won't have a pdf on that state [non-emitting state]. This is equivalent

+ // to setting the <PdfClass> to -1. We do this normally just for the final state.

+ // The Topology object can have multiple <TopologyEntry> blocks.

+ // This is useful if there are multiple types of topology in the system.

+

+ <Topology>

+ <TopologyEntry>

+ <ForPhones> 1 2 3 4 5 6 7 8 </ForPhones>

+ <State> 0 <PdfClass> 0

+ <Transition> 0 0.5

+ <Transition> 1 0.5

+ </State>

+ <State> 1 <PdfClass> 1

+ <Transition> 1 0.5

+ <Transition> 2 0.5

+ </State>

+ <State> 2 <PdfClass> 2

+ <Transition> 2 0.5

+ <Transition> 3 0.5

+ <Final> 0.5

+ </State>

+ <State> 3

+ </State>

+ </TopologyEntry>

+ </Topology>

+*/

+

+// kNoPdf is used where pdf_class or pdf would be used, to indicate,

+// none is there. Mainly useful in skippable models, but also used

+// for end states.

+// A caveat with nonemitting states is that their out-transitions

+// are not trainable, due to technical issues with the way

+// we decided to accumulate the stats. Any transitions arising from (*)

+// HMM states with "kNoPdf" as the label are second-class transitions,

+// They do not have "transition-states" or "transition-ids" associated

+// with them. They are used to create the FST version of the

+// HMMs, where they lead to epsilon arcs.

+// (*) "arising from" is a bit of a technical term here, due to the way

+// (if reorder == true), we put the transition-id associated with the

+// outward arcs of the state, on the input transition to the state.

+

+/// A constant used in the HmmTopology class as the \ref pdf_class "pdf-class"

+/// kNoPdf, which is used when a HMM-state is nonemitting (has no associated

+/// PDF).

+

+static const int32 kNoPdf = -1;

+

+/// A class for storing topology information for phones. See \ref hmm for context.

+/// This object is sometimes accessed in a file by itself, but more often

+/// as a class member of the Transition class (this is for convenience to reduce

+/// the number of files programs have to access).

+

+class HmmTopology {

+ public:

+ /// A structure defined inside HmmTopology to represent a HMM state.

+ struct HmmState {

+ /// The \ref pdf_class pdf-class, typically 0, 1 or 2 (the same as the HMM-state index),

+ /// but may be different to enable us to hardwire sharing of state, and may be

+ /// equal to \ref kNoPdf == -1 in order to specify nonemitting states (unusual).

+ int32 pdf_class;

+

+ /// A list of transitions. The first member of each pair is the index of

+ /// the next HmmState, and the second is the default transition probability

+ /// (before training).

+ std::vector<std::pair<int32, BaseFloat> > transitions;

+

+ explicit HmmState(int32 p): pdf_class(p) { }

+

+ bool operator == (const HmmState &other) const {

+ return (pdf_class == other.pdf_class && transitions == other.transitions);

+ }

+

+ HmmState(): pdf_class(-1) { }

+ };

+

+ /// TopologyEntry is a typedef that represents the topology of

+ /// a single (prototype) state.

+ typedef std::vector<HmmState> TopologyEntry;

+

+ void Read(std::istream &is, bool binary);

+ void Write(std::ostream &os, bool binary) const;

+

+ // Checks that the object is valid, and throw exception otherwise.

+ void Check();

+

+

+ /// Returns the topology entry (i.e. vector of HmmState) for this phone;

+ /// will throw exception if phone not covered by the topology.

+ const TopologyEntry &TopologyForPhone(int32 phone) const;

+

+ /// Returns the number of \ref pdf_class "pdf-classes" for this phone;

+ /// throws exception if phone not covered by this topology.

+ int32 NumPdfClasses(int32 phone) const;

+

+ /// Returns a reference to a sorted, unique list of phones covered by

+ /// the topology (these phones will be positive integers, and usually

+ /// contiguous and starting from one but the toolkit doesn't assume

+ /// they are contiguous).

+ const std::vector<int32> &GetPhones() const { return phones_; };

+

+ /// Outputs a vector of int32, indexed by phone, that gives the

+ /// number of \ref pdf_class pdf-classes for the phones; this is

+ /// used by tree-building code such as BuildTree().

+ void GetPhoneToNumPdfClasses(std::vector<int32> *phone2num_pdf_classes) const;

+

+ HmmTopology() {}

+

+ bool operator == (const HmmTopology &other) const {

+ return phones_ == other.phones_ && phone2idx_ == other.phone2idx_

+ && entries_ == other.entries_;

+ }

+ // Allow default assignment operator and copy constructor.

+ private:

+ std::vector<int32> phones_; // list of all phones we have topology for. Sorted, uniq. no epsilon (zero) phone.

+ std::vector<int32> phone2idx_; // map from phones to indexes into the entries vector (or -1 for not present).

+ std::vector<TopologyEntry> entries_;

+};

+

+

+/// This function returns a HmmTopology object giving a normal 3-state topology,

+/// covering all phones in the list "phones". This is mainly of use in testing

+/// code.

+HmmTopology GetDefaultTopology(const std::vector<int32> &phones);

+

+/// @} end "addtogroup hmm_group"

+

+

+} // end namespace kaldi

+

+

+#endif

+// hmm/hmm-utils.h

+

+// Copyright 2009-2011 Microsoft Corporation

+

+// 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.

+

+#ifndef KALDI_HMM_HMM_UTILS_H_

+#define KALDI_HMM_HMM_UTILS_H_

+

+#include "hmm/hmm-topology.h"

+#include "hmm/transition-model.h"

+#include "lat/kaldi-lattice.h"

+

+namespace kaldi {

+

+

+/// \defgroup hmm_group_graph Classes and functions for creating FSTs from HMMs

+/// \ingroup hmm_group

+/// @{

+

+/// Configuration class for the GetHTransducer() function; see

+/// \ref hmm_graph_config for context.

+struct HTransducerConfig {

+ /// Transition log-prob scale, see \ref hmm_scale.

+ /// Note this doesn't apply to self-loops; GetHTransducer() does

+ /// not include self-loops.

+ BaseFloat transition_scale;

+

+ /// if true, we are constructing time-reversed FST: phone-seqs in ilabel_info

+ /// are backwards, and we want to output a backwards version of the HMM

+ /// corresponding to each phone. If reverse == true,

+ bool reverse;

+

+ /// This variable is only looked at if reverse == true. If reverse == true

+ /// and push_weights == true, then we push the weights in the reversed FSTs we create for each

+ /// phone HMM. This is only safe if the HMMs are probabilistic (i.e. not discriminatively

+ bool push_weights;

+

+ /// delta used if we do push_weights [only relevant if reverse == true

+ /// and push_weights == true].

+ BaseFloat push_delta;

+

+ HTransducerConfig():

+ transition_scale(1.0),

+ reverse(false),

+ push_weights(true),

+ push_delta(0.001)

+ { }

+

+ // Note-- this Register registers the easy-to-register options

+ // but not the "sym_type" which is an enum and should be handled

+ // separately in main().

+ void Register (OptionsItf *po) {

+ po->Register("transition-scale", &transition_scale,

+ "Scale of transition probs (relative to LM)");

+ po->Register("reverse", &reverse,

+ "Set true to build time-reversed FST.");

+ po->Register("push-weights", &push_weights,

+ "Push weights (only applicable if reverse == true)");

+ po->Register("push-delta", &push_delta,

+ "Delta used in pushing weights (only applicable if "

+ "reverse && push-weights");

+ }

+};

+

+

+struct HmmCacheHash {

+ int operator () (const std::pair<int32, std::vector<int32> >&p) const {

+ VectorHasher<int32> v;

+ int32 prime = 103049;

+ return prime*p.first + v(p.second);

+ }

+};

+

+/// HmmCacheType is a map from (central-phone, sequence of pdf-ids) to FST, used

+/// as cache in GetHmmAsFst, as an optimization.

+typedef unordered_map<std::pair<int32, std::vector<int32> >,

+ fst::VectorFst<fst::StdArc>*,

+ HmmCacheHash> HmmCacheType;

+

+

+/// Called by GetHTransducer() and probably will not need to be called directly;

+/// it creates the FST corresponding to the phone. Does not include self-loops;

+/// you have to call AddSelfLoops() for that. Result owned by caller.

+/// Returns an acceptor (i.e. ilabels, olabels identical) with transition-ids

+/// as the symbols.

+/// For documentation in context, see \ref hmm_graph_get_hmm_as_fst

+/// @param context_window A vector representing the phonetic context; see

+/// \ref tree_window "here" for explanation.

+/// @param ctx_dep The object that contains the phonetic decision-tree

+/// @param trans_model The transition-model object, which provides

+/// the mappings to transition-ids and also the transition

+/// probabilities.

+/// @param config Configuration object, see \ref HTransducerConfig.

+/// @param cache Object used as a lookaside buffer to save computation;

+/// if it finds that the object it needs is already there, it will

+/// just return a pointer value from "cache"-- not that this means

+/// you have to be careful not to delete things twice.

+

+fst::VectorFst<fst::StdArc> *GetHmmAsFst(

+ std::vector<int32> context_window,

+ const ContextDependencyInterface &ctx_dep,

+ const TransitionModel &trans_model,

+ const HTransducerConfig &config,

+ HmmCacheType *cache = NULL);

+

+/// Included mainly as a form of documentation, not used in any other code

+/// currently. Creates the FST with self-loops, and with fewer options.

+fst::VectorFst<fst::StdArc>*

+GetHmmAsFstSimple(std::vector<int32> context_window,

+ const ContextDependencyInterface &ctx_dep,

+ const TransitionModel &trans_model,

+ BaseFloat prob_scale);

+

+

+/**

+ * Returns the H tranducer; result owned by caller.

+ * See \ref hmm_graph_get_h_transducer. The H transducer has on the

+ * input transition-ids, and also possibly some disambiguation symbols, which

+ * will be put in disambig_syms. The output side contains the identifiers that

+ * are indexes into "ilabel_info" (these represent phones-in-context or

+ * disambiguation symbols). The ilabel_info vector allows GetHTransducer to map

+ * from symbols to phones-in-context (i.e. phonetic context windows). Any

+ * singleton symbols in the ilabel_info vector which are not phones, will be

+ * treated as disambiguation symbols. [Not all recipes use these]. The output

+ * "disambig_syms_left" will be set to a list of the disambiguation symbols on

+ * the input of the transducer (i.e. same symbol type as whatever is on the

+ * input of the transducer

+ */

+fst::VectorFst<fst::StdArc>*

+GetHTransducer (const std::vector<std::vector<int32> > &ilabel_info,

+ const ContextDependencyInterface &ctx_dep,

+ const TransitionModel &trans_model,

+ const HTransducerConfig &config,

+ std::vector<int32> *disambig_syms_left);

+

+/**

+ * GetIlabelMapping produces a mapping that's similar to HTK's logical-to-physical

+ * model mapping (i.e. the xwrd.clustered.mlist files). It groups together

+ * "logical HMMs" (i.e. in our world, phonetic context windows) that share the

+ * same sequence of transition-ids. This can be used in an

+ * optional graph-creation step that produces a remapped form of CLG that can be

+ * more productively determinized and minimized. This is used in the command-line program

+ * make-ilabel-transducer.cc.

+ * @param ilabel_info_old [in] The original \ref tree_ilabel "ilabel_info" vector

+ * @param ctx_dep [in] The tree

+ * @param trans_model [in] The transition-model object

+ * @param old2new_map [out] The output; this vector, which is of size equal to the

+ * number of new labels, is a mapping to the old labels such that we could

+ * create a vector ilabel_info_new such that

+ * ilabel_info_new[i] == ilabel_info_old[old2new_map[i]]

+ */

+void GetIlabelMapping (const std::vector<std::vector<int32> > &ilabel_info_old,

+ const ContextDependencyInterface &ctx_dep,

+ const TransitionModel &trans_model,

+ std::vector<int32> *old2new_map);

+

+

+

+/**

+ * For context, see \ref hmm_graph_add_self_loops. Expands an FST that has been

+ * built without self-loops, and adds the self-loops (it also needs to modify

+ * the probability of the non-self-loop ones, as the graph without self-loops

+ * was created in such a way that it was stochastic). Note that the

+ * disambig_syms will be empty in some recipes (e.g. if you already removed

+ * the disambiguation symbols).

+ * @param trans_model [in] Transition model

+ * @param disambig_syms [in] Sorted, uniq list of disambiguation symbols, required

+ * if the graph contains disambiguation symbols but only needed for sanity checks.

+ * @param self_loop_scale [in] Transition-probability scale for self-loops; c.f.

+ * \ref hmm_scale

+ * @param reorder [in] If true, reorders the transitions (see \ref hmm_reorder).

+ * @param fst [in, out] The FST to be modified.

+ */

+void AddSelfLoops(const TransitionModel &trans_model,

+ const std::vector<int32> &disambig_syms, // used as a check only.

+ BaseFloat self_loop_scale,

+ bool reorder, // true->dan-style, false->lukas-style.

+ fst::VectorFst<fst::StdArc> *fst);

+

+/**

+ * Adds transition-probs, with the supplied

+ * scales (see \ref hmm_scale), to the graph.

+ * Useful if you want to create a graph without transition probs, then possibly

+ * train the model (including the transition probs) but keep the graph fixed,

+ * and add back in the transition probs. It assumes the fst has transition-ids

+ * on it. It is not an error if the FST has no states (nothing will be done).

+ * @param trans_model [in] The transition model

+ * @param disambig_syms [in] A list of disambiguation symbols, required if the

+ * graph has disambiguation symbols on its input but only

+ * used for checks.

+ * @param transition_scale [in] A scale on transition-probabilities apart from

+ * those involving self-loops; see \ref hmm_scale.

+ * @param self_loop_scale [in] A scale on self-loop transition probabilities;

+ * see \ref hmm_scale.

+ * @param fst [in, out] The FST to be modified.

+ */

+void AddTransitionProbs(const TransitionModel &trans_model,

+ const std::vector<int32> &disambig_syms,

+ BaseFloat transition_scale,

+ BaseFloat self_loop_scale,

+ fst::VectorFst<fst::StdArc> *fst);

+

+/**

+ This is as AddSelfLoops(), but operates on a Lattice, where

+ it affects the graph part of the weight (the first element

+ of the pair). */

+void AddTransitionProbs(const TransitionModel &trans_model,

+ BaseFloat transition_scale,

+ BaseFloat self_loop_scale,

+ Lattice *lat);

+

+

+/// Returns a transducer from pdfs plus one (input) to transition-ids (output).

+/// Currenly of use only for testing.

+fst::VectorFst<fst::StdArc>*

+GetPdfToTransitionIdTransducer(const TransitionModel &trans_model);

+

+/// Converts all transition-ids in the FST to pdfs plus one.

+/// Placeholder: not implemented yet!

+void ConvertTransitionIdsToPdfs(const TransitionModel &trans_model,

+ const std::vector<int32> &disambig_syms,

+ fst::VectorFst<fst::StdArc> *fst);

+

+/// @} end "defgroup hmm_group_graph"

+

+/// \addtogroup hmm_group

+/// @{

+

+/// SplitToPhones splits up the TransitionIds in "alignment" into their

+/// individual phones (one vector per instance of a phone). At output,

+/// the sum of the sizes of the vectors in split_alignment will be the same

+/// as the corresponding sum for "alignment". The function returns

+/// true on success. If the alignment appears to be incomplete, e.g.

+/// not ending at the end-state of a phone, it will still break it up into

+/// phones but it will return false. For more serious errors it will

+/// die or throw an exception.

+/// This function works out by itself whether the graph was created

+/// with "reordering" (dan-style graph), and just does the right thing.

+

+bool SplitToPhones(const TransitionModel &trans_model,

+ const std::vector<int32> &alignment,

+ std::vector<std::vector<int32> > *split_alignment);

+

+/// ConvertAlignment converts an alignment that was created using one

+/// model, to another model. They must use a compatible topology (so we

+/// know the state alignments of the new model).

+/// It returns false if it could not be split to phones (probably

+/// because the alignment was partial), but for other kinds of

+/// error that are more likely a coding error, it will throw

+/// an exception.

+bool ConvertAlignment(const TransitionModel &old_trans_model,

+ const TransitionModel &new_trans_model,

+ const ContextDependencyInterface &new_ctx_dep,

+ const std::vector<int32> &old_alignment,

+ const std::vector<int32> *phone_map, // may be NULL

+ std::vector<int32> *new_alignment);

+

+// ConvertPhnxToProns is only needed in bin/phones-to-prons.cc and

+// isn't closely related with HMMs, but we put it here as there isn't

+// any other obvious place for it and it needs to be tested.

+// This function takes a phone-sequence with word-start and word-end

+// markers in it, and a word-sequence, and outputs the pronunciations

+// "prons"... the format of "prons" is, each element is a vector,

+// where the first element is the word (or zero meaning no word, e.g.

+// for optional silence introduced by the lexicon), and the remaining

+// elements are the phones in the word's pronunciation.

+// It returns false if it encounters a problem of some kind, e.g.

+// if the phone-sequence doesn't seem to have the right number of

+// words in it.

+bool ConvertPhnxToProns(const std::vector<int32> &phnx,

+ const std::vector<int32> &words,

+ int32 word_start_sym,

+ int32 word_end_sym,

+ std::vector<std::vector<int32> > *prons);

+

+/// @} end "addtogroup hmm_group"

+

+} // end namespace kaldi

+

+

+#endif

+// hmm/posterior.h

+

+// Copyright 2009-2011 Microsoft Corporation

+// 2013-2014 Johns Hopkins University (author: Daniel Povey)

+// 2014 Guoguo Chen

+

+

+// 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.

+

+#ifndef KALDI_HMM_POSTERIOR_H_

+#define KALDI_HMM_POSTERIOR_H_

+

+#include "base/kaldi-common.h"

+#include "tree/context-dep.h"

+#include "util/const-integer-set.h"

+#include "util/kaldi-table.h"

+#include "hmm/transition-model.h"

+

+

+namespace kaldi {

+

+

+/// \addtogroup posterior_group

+/// @{

+

+/// Posterior is a typedef for storing acoustic-state (actually, transition-id)

+/// posteriors over an utterance. The "int32" is a transition-id, and the BaseFloat

+/// is a probability (typically between zero and one).

+typedef std::vector<std::vector<std::pair<int32, BaseFloat> > > Posterior;

+

+/// GaussPost is a typedef for storing Gaussian-level posteriors for an utterance.

+/// the "int32" is a transition-id, and the Vector<BaseFloat> is a vector of

+/// Gaussian posteriors.

+/// WARNING: We changed "int32" from transition-id to pdf-id, and the change is

+/// applied for all programs using GaussPost. This is for efficiency purpose. We

+/// also changed the name slightly from GauPost to GaussPost to reduce the

+/// chance that the change will go un-noticed in downstream code.

+typedef std::vector<std::vector<std::pair<int32, Vector<BaseFloat> > > > GaussPost;

+

+

+// PosteriorHolder is a holder for Posterior, which is

+// std::vector<std::vector<std::pair<int32, BaseFloat> > >

+// This is used for storing posteriors of transition id's for an

+// utterance.

+class PosteriorHolder {

+ public:

+ typedef Posterior T;

+

+ PosteriorHolder() { }

+

+ static bool Write(std::ostream &os, bool binary, const T &t);

+

+ void Clear() { Posterior tmp; std::swap(tmp, t_); }

+

+ // Reads into the holder.

+ bool Read(std::istream &is);

+

+ // Kaldi objects always have the stream open in binary mode for

+ // reading.

+ static bool IsReadInBinary() { return true; }

+

+ const T &Value() const { return t_; }

+

+ private:

+ KALDI_DISALLOW_COPY_AND_ASSIGN(PosteriorHolder);

+ T t_;

+};

+

+

+// GaussPostHolder is a holder for GaussPost, which is

+// std::vector<std::vector<std::pair<int32, Vector<BaseFloat> > > >

+// This is used for storing posteriors of transition id's for an

+// utterance.

+class GaussPostHolder {

+ public:

+ typedef GaussPost T;

+

+ GaussPostHolder() { }

+

+ static bool Write(std::ostream &os, bool binary, const T &t);

+

+ void Clear() { GaussPost tmp; std::swap(tmp, t_); }

+

+ // Reads into the holder.

+ bool Read(std::istream &is);

+

+ // Kaldi objects always have the stream open in binary mode for

+ // reading.

+ static bool IsReadInBinary() { return true; }

+

+ const T &Value() const { return t_; }

+

+ private:

+ KALDI_DISALLOW_COPY_AND_ASSIGN(GaussPostHolder);

+ T t_;

+};

+

+

+// Posterior is a typedef: vector<vector<pair<int32, BaseFloat> > >,

+// representing posteriors over (typically) transition-ids for an

+// utterance.

+typedef TableWriter<PosteriorHolder> PosteriorWriter;

+typedef SequentialTableReader<PosteriorHolder> SequentialPosteriorReader;

+typedef RandomAccessTableReader<PosteriorHolder> RandomAccessPosteriorReader;

+

+

+// typedef std::vector<std::vector<std::pair<int32, Vector<BaseFloat> > > > GaussPost;

+typedef TableWriter<GaussPostHolder> GaussPostWriter;

+typedef SequentialTableReader<GaussPostHolder> SequentialGaussPostReader;

+typedef RandomAccessTableReader<GaussPostHolder> RandomAccessGaussPostReader;

+

+

+/// Scales the BaseFloat (weight) element in the posterior entries.

+void ScalePosterior(BaseFloat scale, Posterior *post);

+

+/// Returns the total of all the weights in "post".

+BaseFloat TotalPosterior(const Posterior &post);

+

+/// Returns true if the two lists of pairs have no common .first element.

+bool PosteriorEntriesAreDisjoint(

+ const std::vector<std::pair<int32, BaseFloat> > &post_elem1,

+ const std::vector<std::pair<int32, BaseFloat> > &post_elem2);

+

+

+/// Merge two sets of posteriors, which must have the same length. If "merge"

+/// is true, it will make a common entry whenever there are duplicated entries,

+/// adding up the weights. If "drop_frames" is true, for frames where the

+/// two sets of posteriors were originally disjoint, makes no entries for that

+/// frame (relates to frame dropping, or drop_frames, see Vesely et al, ICASSP

+/// 2013). Returns the number of frames for which the two posteriors were

+/// disjoint (i.e. no common transition-ids or whatever index we are using).

+int32 MergePosteriors(const Posterior &post1,

+ const Posterior &post2,

+ bool merge,

+ bool drop_frames,

+ Posterior *post);

+

+/// Given a vector of log-likelihoods (typically of Gaussians in a GMM

+/// but could be of pdf-ids), a number gselect >= 1 and a minimum posterior

+/// 0 <= min_post < 1, it gets the posterior for each element of log-likes

+/// by applying Softmax(), then prunes the posteriors using "gselect" and

+/// "min_post" (keeping at least one), and outputs the result into

+/// "post_entry", sorted from greatest to least posterior.

+/// Returns the total log-likelihood (the output of calling ApplySoftMax()

+/// on a copy of log_likes).

+BaseFloat VectorToPosteriorEntry(

+ const VectorBase<BaseFloat> &log_likes,

+ int32 num_gselect,

+ BaseFloat min_post,

+ std::vector<std::pair<int32, BaseFloat> > *post_entry);

+

+/// Convert an alignment to a posterior (with a scale of 1.0 on

+/// each entry).

+void AlignmentToPosterior(const std::vector<int32> &ali,

+ Posterior *post);

+

+/// Sorts posterior entries so that transition-ids with same pdf-id are next to

+/// each other.

+void SortPosteriorByPdfs(const TransitionModel &tmodel,

+ Posterior *post);

+

+

+/// Converts a posterior over transition-ids to be a posterior

+/// over pdf-ids.

+void ConvertPosteriorToPdfs(const TransitionModel &tmodel,

+ const Posterior &post_in,

+ Posterior *post_out);

+

+/// Converts a posterior over transition-ids to be a posterior

+/// over phones.

+void ConvertPosteriorToPhones(const TransitionModel &tmodel,

+ const Posterior &post_in,

+ Posterior *post_out);

+

+/// Weight any silence phones in the posterior (i.e. any phones

+/// in the set "silence_set" by scale "silence_scale".

+/// The interface was changed in Feb 2014 to do the modification

+/// "in-place" rather than having separate input and output.

+void WeightSilencePost(const TransitionModel &trans_model,

+ const ConstIntegerSet<int32> &silence_set,

+ BaseFloat silence_scale,

+ Posterior *post);

+

+/// This is similar to WeightSilencePost, except that on each frame it

+/// works out the amount by which the overall posterior would be reduced,

+/// and scales down everything on that frame by the same amount. It

+/// has the effect that frames that are mostly silence get down-weighted.

+/// The interface was changed in Feb 2014 to do the modification

+/// "in-place" rather than having separate input and output.

+void WeightSilencePostDistributed(const TransitionModel &trans_model,

+ const ConstIntegerSet<int32> &silence_set,

+ BaseFloat silence_scale,

+ Posterior *post);

+

+/// @} end "addtogroup posterior_group"

+

+

+} // end namespace kaldi

+

+

+#endif

+// hmm/transition-model.h

+

+// Copyright 2009-2012 Microsoft Corporation

+// Johns Hopkins University (author: Guoguo Chen)

+

+// 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.

+

+#ifndef KALDI_HMM_TRANSITION_MODEL_H_

+#define KALDI_HMM_TRANSITION_MODEL_H_

+

+#include "base/kaldi-common.h"

+#include "tree/context-dep.h"

+#include "util/const-integer-set.h"

+#include "fst/fst-decl.h" // forward declarations.

+#include "hmm/hmm-topology.h"

+#include "itf/options-itf.h"

+

+namespace kaldi {

+

+/// \addtogroup hmm_group

+/// @{

+

+// The class TransitionModel is a repository for the transition probabilities.

+// It also handles certain integer mappings.

+// The basic model is as follows. Each phone has a HMM topology defined in

+// hmm-topology.h. Each HMM-state of each of these phones has a number of

+// transitions (and final-probs) out of it. Each HMM-state defined in the

+// HmmTopology class has an associated "pdf_class". This gets replaced with

+// an actual pdf-id via the tree. The transition model associates the

+// transition probs with the (phone, HMM-state, pdf-id). We associate with

+// each such triple a transition-state. Each

+// transition-state has a number of associated probabilities to estimate;

+// this depends on the number of transitions/final-probs in the topology for

+// that (phone, HMM-state). Each probability has an associated transition-index.

+// We associate with each (transition-state, transition-index) a unique transition-id.

+// Each individual probability estimated by the transition-model is asociated with a

+// transition-id.

+//

+// List of the various types of quantity referred to here and what they mean:

+// phone: a phone index (1, 2, 3 ...)

+// HMM-state: a number (0, 1, 2...) that indexes TopologyEntry (see hmm-topology.h)

+// pdf-id: a number output by the Compute function of ContextDependency (it

+// indexes pdf's). Zero-based.

+// transition-state: the states for which we estimate transition probabilities for transitions

+// out of them. In some topologies, will map one-to-one with pdf-ids.

+// One-based, since it appears on FSTs.

+// transition-index: identifier of a transition (or final-prob) in the HMM. Indexes the

+// "transitions" vector in HmmTopology::HmmState. [if it is out of range,

+// equal to transitions.size(), it refers to the final-prob.]

+// Zero-based.

+// transition-id: identifier of a unique parameter of the TransitionModel.

+// Associated with a (transition-state, transition-index) pair.

+// One-based, since it appears on FSTs.

+//

+// List of the possible mappings TransitionModel can do:

+// (phone, HMM-state, pdf-id) -> transition-state

+// (transition-state, transition-index) -> transition-id

+// Reverse mappings:

+// transition-id -> transition-state

+// transition-id -> transition-index

+// transition-state -> phone

+// transition-state -> HMM-state

+// transition-state -> pdf-id

+//

+// The main things the TransitionModel object can do are:

+// Get initialized (need ContextDependency and HmmTopology objects).

+// Read/write.

+// Update [given a vector of counts indexed by transition-id].

+// Do the various integer mappings mentioned above.

+// Get the probability (or log-probability) associated with a particular transition-id.

+

+

+// Note: this was previously called TransitionUpdateConfig.

+struct MleTransitionUpdateConfig {

+ BaseFloat floor;

+ BaseFloat mincount;

+ bool share_for_pdfs; // If true, share all transition parameters that have the same pdf.

+ MleTransitionUpdateConfig(BaseFloat floor = 0.01,

+ BaseFloat mincount = 5.0,

+ bool share_for_pdfs = false):

+ floor(floor), mincount(mincount), share_for_pdfs(share_for_pdfs) {}

+

+ void Register (OptionsItf *po) {

+ po->Register("transition-floor", &floor,

+ "Floor for transition probabilities");

+ po->Register("transition-min-count", &mincount,

+ "Minimum count required to update transitions from a state");

+ po->Register("share-for-pdfs", &share_for_pdfs,

+ "If true, share all transition parameters where the states "

+ "have the same pdf.");

+ }

+};

+

+struct MapTransitionUpdateConfig {

+ BaseFloat tau;

+ bool share_for_pdfs; // If true, share all transition parameters that have the same pdf.

+ MapTransitionUpdateConfig(): tau(5.0), share_for_pdfs(false) { }

+

+ void Register (OptionsItf *po) {

+ po->Register("transition-tau", &tau, "Tau value for MAP estimation of transition "

+ "probabilities.");

+ po->Register("share-for-pdfs", &share_for_pdfs,

+ "If true, share all transition parameters where the states "

+ "have the same pdf.");

+ }

+};

+

+class TransitionModel {

+

+ public:

+ /// Initialize the object [e.g. at the start of training].

+ /// The class keeps a copy of the HmmTopology object, but not

+ /// the ContextDependency object.

+ TransitionModel(const ContextDependency &ctx_dep,

+ const HmmTopology &hmm_topo);

+

+

+ /// Constructor that takes no arguments: typically used prior to calling Read.

+ TransitionModel() { }

+

+ void Read(std::istream &is, bool binary); // note, no symbol table: topo object always read/written w/o symbols.

+ void Write(std::ostream &os, bool binary) const;

+

+

+ /// return reference to HMM-topology object.

+ const HmmTopology &GetTopo() const { return topo_; }

+

+ /// \name Integer mapping functions

+ /// @{

+

+ int32 TripleToTransitionState(int32 phone, int32 hmm_state, int32 pdf) const;

+ int32 PairToTransitionId(int32 trans_state, int32 trans_index) const;

+ int32 TransitionIdToTransitionState(int32 trans_id) const;

+ int32 TransitionIdToTransitionIndex(int32 trans_id) const;

+ int32 TransitionStateToPhone(int32 trans_state) const;

+ int32 TransitionStateToHmmState(int32 trans_state) const;

+ int32 TransitionStateToPdf(int32 trans_state) const;

+ int32 SelfLoopOf(int32 trans_state) const; // returns the self-loop transition-id, or zero if

+ // this state doesn't have a self-loop.

+

+ inline int32 TransitionIdToPdf(int32 trans_id) const;

+ int32 TransitionIdToPhone(int32 trans_id) const;

+ int32 TransitionIdToPdfClass(int32 trans_id) const;

+ int32 TransitionIdToHmmState(int32 trans_id) const;

+

+ /// @}

+

+ bool IsFinal(int32 trans_id) const; // returns true if this trans_id goes to the final state

+ // (which is bound to be nonemitting).

+ bool IsSelfLoop(int32 trans_id) const; // return true if this trans_id corresponds to a self-loop.

+

+ /// Returns the total number of transition-ids (note, these are one-based).

+ inline int32 NumTransitionIds() const { return id2state_.size()-1; }

+

+ /// Returns the number of transition-indices for a particular transition-state.

+ /// Note: "Indices" is the plural of "index". Index is not the same as "id",

+ /// here. A transition-index is a zero-based offset into the transitions

+ /// out of a particular transition state.

+ int32 NumTransitionIndices(int32 trans_state) const;

+

+ /// Returns the total number of transition-states (note, these are one-based).

+ int32 NumTransitionStates() const { return triples_.size(); }

+

+ // NumPdfs() actually returns the highest-numbered pdf we ever saw, plus one.

+ // In normal cases this should equal the number of pdfs in the system, but if you

+ // initialized this object with fewer than all the phones, and it happens that

+ // an unseen phone has the highest-numbered pdf, this might be different.

+ int32 NumPdfs() const { return num_pdfs_; }

+

+ // This loops over the triples and finds the highest phone index present. If

+ // the FST symbol table for the phones is created in the expected way, i.e.:

+ // starting from 1 (<eps> is 0) and numbered contiguously till the last phone,

+ // this will be the total number of phones.

+ int32 NumPhones() const;

+

+ /// Returns a sorted, unique list of phones.

+ const std::vector<int32> &GetPhones() const { return topo_.GetPhones(); }

+

+ // Transition-parameter-getting functions:

+ BaseFloat GetTransitionProb(int32 trans_id) const;

+ BaseFloat GetTransitionLogProb(int32 trans_id) const;

+

+ // The following functions are more specialized functions for getting

+ // transition probabilities, that are provided for convenience.

+

+ /// Returns the log-probability of a particular non-self-loop transition

+ /// after subtracting the probability mass of the self-loop and renormalizing;

+ /// will crash if called on a self-loop. Specifically:

+ /// for non-self-loops it returns the log of that prob divided by (1 minus

+ /// self-loop-prob-for-that-state).

+ BaseFloat GetTransitionLogProbIgnoringSelfLoops(int32 trans_id) const;

+

+ /// Returns the log-prob of the non-self-loop probability

+ /// mass for this transition state. (you can get the self-loop prob, if a self-loop

+ /// exists, by calling GetTransitionLogProb(SelfLoopOf(trans_state)).

+ BaseFloat GetNonSelfLoopLogProb(int32 trans_state) const;

+

+ /// Does Maximum Likelihood estimation. The stats are counts/weights, indexed

+ /// by transition-id. This was previously called Update().

+ void MleUpdate(const Vector<double> &stats,

+ const MleTransitionUpdateConfig &cfg,

+ BaseFloat *objf_impr_out,

+ BaseFloat *count_out);

+

+ /// Does Maximum A Posteriori (MAP) estimation. The stats are counts/weights,

+ /// indexed by transition-id.

+ void MapUpdate(const Vector<double> &stats,

+ const MapTransitionUpdateConfig &cfg,

+ BaseFloat *objf_impr_out,

+ BaseFloat *count_out);

+

+ /// Print will print the transition model in a human-readable way, for purposes of human

+ /// inspection. The "occs" are optional (they are indexed by pdf-id).

+ void Print(std::ostream &os,

+ const std::vector<std::string> &phone_names,

+ const Vector<double> *occs = NULL);

+

+

+ void InitStats(Vector<double> *stats) const { stats->Resize(NumTransitionIds()+1); }

+

+ void Accumulate(BaseFloat prob, int32 trans_id, Vector<double> *stats) const {

+ KALDI_ASSERT(trans_id <= NumTransitionIds());

+ (*stats)(trans_id) += prob;

+ // This is trivial and doesn't require class members, but leaves us more open

+ // to design changes than doing it manually.

+ }

+

+ /// returns true if all the integer class members are identical (but does not

+ /// compare the transition probabilities.

+ bool Compatible(const TransitionModel &other) const;

+

+ private:

+ void MleUpdateShared(const Vector<double> &stats,

+ const MleTransitionUpdateConfig &cfg,

+ BaseFloat *objf_impr_out, BaseFloat *count_out);

+ void MapUpdateShared(const Vector<double> &stats,

+ const MapTransitionUpdateConfig &cfg,

+ BaseFloat *objf_impr_out, BaseFloat *count_out);

+ void ComputeTriples(const ContextDependency &ctx_dep); // called from constructor. initializes triples_.

+ void ComputeDerived(); // called from constructor and Read function: computes state2id_ and id2state_.

+ void ComputeDerivedOfProbs(); // computes quantities derived from log-probs (currently just

+ // non_self_loop_log_probs_; called whenever log-probs change.

+ void InitializeProbs(); // called from constructor.

+ void Check() const;

+

+ struct Triple {

+ int32 phone;

+ int32 hmm_state;

+ int32 pdf;

+ Triple() { }

+ Triple(int32 phone, int32 hmm_state, int32 pdf):

+ phone(phone), hmm_state(hmm_state), pdf(pdf) { }

+ bool operator < (const Triple &other) const {

+ if (phone < other.phone) return true;

+ else if (phone > other.phone) return false;

+ else if (hmm_state < other.hmm_state) return true;

+ else if (hmm_state > other.hmm_state) return false;

+ else return pdf < other.pdf;

+ }

+ bool operator == (const Triple &other) const {

+ return (phone == other.phone && hmm_state == other.hmm_state

+ && pdf == other.pdf);

+ }

+ };

+

+ HmmTopology topo_;

+

+ /// Triples indexed by transition state minus one;

+ /// the triples are in sorted order which allows us to do the reverse mapping from

+ /// triple to transition state

+ std::vector<Triple> triples_;

+

+ /// Gives the first transition_id of each transition-state; indexed by

+ /// the transition-state. Array indexed 1..num-transition-states+1 (the last one

+ /// is needed so we can know the num-transitions of the last transition-state.

+ std::vector<int32> state2id_;

+

+ /// For each transition-id, the corresponding transition

+ /// state (indexed by transition-id).

+ std::vector<int32> id2state_;

+

+ /// For each transition-id, the corresponding log-prob. Indexed by transition-id.

+ Vector<BaseFloat> log_probs_;

+

+ /// For each transition-state, the log of (1 - self-loop-prob). Indexed by

+ /// transition-state.

+ Vector<BaseFloat> non_self_loop_log_probs_;

+

+ /// This is actually one plus the highest-numbered pdf we ever got back from the

+ /// tree (but the tree numbers pdfs contiguously from zero so this is the number

+ /// of pdfs).

+ int32 num_pdfs_;

+

+

+ DISALLOW_COPY_AND_ASSIGN(TransitionModel);

+

+};

+

+inline int32 TransitionModel::TransitionIdToPdf(int32 trans_id) const {

+ // If a lot of time is spent here we may create an extra array

+ // to handle this.

+ KALDI_ASSERT(static_cast<size_t>(trans_id) < id2state_.size() &&

+ "Likely graph/model mismatch (graph built from wrong model?)");

+ int32 trans_state = id2state_[trans_id];

+ return triples_[trans_state-1].pdf;

+}

+

+/// Works out which pdfs might correspond to the given phones. Will return true

+/// if these pdfs correspond *just* to these phones, false if these pdfs are also

+/// used by other phones.

+/// @param trans_model [in] Transition-model used to work out this information

+/// @param phones [in] A sorted, uniq vector that represents a set of phones

+/// @param pdfs [out] Will be set to a sorted, uniq list of pdf-ids that correspond

+/// to one of this set of phones.

+/// @return Returns true if all of the pdfs output to "pdfs" correspond to phones from

+/// just this set (false if they may be shared with phones outside this set).

+bool GetPdfsForPhones(const TransitionModel &trans_model,

+ const std::vector<int32> &phones,

+ std::vector<int32> *pdfs);

+

+/// Works out which phones might correspond to the given pdfs. Similar to the

+/// above GetPdfsForPhones(, ,)

+bool GetPhonesForPdfs(const TransitionModel &trans_model,

+ const std::vector<int32> &pdfs,

+ std::vector<int32> *phones);

+/// @}

+

+

+} // end namespace kaldi

+

+

+#endif

+// hmm/tree-accu.h

+

+// Copyright 2009-2011 Microsoft Corporation

+// 2013 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.

+#ifndef KALDI_HMM_TREE_ACCU_H_

+#define KALDI_HMM_TREE_ACCU_H_

+

+#include <cctype> // For isspace.

+#include <limits>

+#include "base/kaldi-common.h"

+#include "hmm/transition-model.h"

+#include "tree/clusterable-classes.h"

+#include "tree/build-tree-questions.h" // needed for this typedef:

+// typedef std::vector<std::pair<EventVector, Clusterable*> > BuildTreeStatsType;

+

+namespace kaldi {

+

+/// \ingroup tree_group_top

+/// @{

+

+

+/// Accumulates the stats needed for training context-dependency trees (in the

+/// "normal" way). It adds to 'stats' the stats obtained from this file. Any

+/// new GaussClusterable* pointers in "stats" will be allocated with "new".

+

+void AccumulateTreeStats(const TransitionModel &trans_model,

+ BaseFloat var_floor,

+ int N, // context window size.

+ int P, // central position.

+ const std::vector<int32> &ci_phones, // sorted

+ const std::vector<int32> &alignment,

+ const Matrix<BaseFloat> &features,

+ const std::vector<int32> *phone_map, // or NULL

+ std::map<EventType, GaussClusterable*> *stats);

+

+

+

+/*** Read a mapping from one phone set to another. The phone map file has lines

+ of the form <old-phone> <new-phone>, where both entries are integers, usually

+ nonzero (but this is not enforced). This program will crash if the input is

+ invalid, e.g. there are multiple inconsistent entries for the same old phone.

+ The output vector "phone_map" will be indexed by old-phone and will contain

+ the corresponding new-phone, or -1 for any entry that was not defined. */

+

+void ReadPhoneMap(std::string phone_map_rxfilename,

+ std::vector<int32> *phone_map);

+

+

+

+/// @}

+

+} // end namespace kaldi.

+

+#endif

+// itf/clusterable-itf.h

+

+// Copyright 2009-2011 Microsoft Corporation; Go Vivace Inc.

+

+// 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.

+

+

+#ifndef KALDI_ITF_CLUSTERABLE_ITF_H_

+#define KALDI_ITF_CLUSTERABLE_ITF_H_ 1

+

+#include <string>

+#include "base/kaldi-common.h"

+

+namespace kaldi {

+

+

+/** \addtogroup clustering_group

+ @{

+ A virtual class for clusterable objects; see \ref clustering for an

+ explanation if its function.

+*/

+

+

+

+class Clusterable {

+ public:

+ /// \name Functions that must be overridden

+ /// @{

+

+ /// Return a copy of this object.

+ virtual Clusterable *Copy() const = 0;

+ /// Return the objective function associated with the stats

+ /// [assuming ML estimation]

+ virtual BaseFloat Objf() const = 0;

+ /// Return the normalizer (typically, count) associated with the stats

+ virtual BaseFloat Normalizer() const = 0;

+ /// Set stats to empty.

+ virtual void SetZero() = 0;

+ /// Add other stats.

+ virtual void Add(const Clusterable &other) = 0;

+ /// Subtract other stats.

+ virtual void Sub(const Clusterable &other) = 0;

+ /// Scale the stats by a positive number f [not mandatory to supply this].

+ virtual void Scale(BaseFloat f) {

+ KALDI_ERR << "This Clusterable object does not implement Scale().";

+ }

+

+ /// Return a string that describes the inherited type.

+ virtual std::string Type() const = 0;

+

+ /// Write data to stream.

+ virtual void Write(std::ostream &os, bool binary) const = 0;

+

+ /// Read data from a stream and return the corresponding object (const

+ /// function; it's a class member because we need access to the vtable

+ /// so generic code can read derived types).

+ virtual Clusterable* ReadNew(std::istream &os, bool binary) const = 0;

+

+ virtual ~Clusterable() {}

+

+ /// @}

+

+ /// \name Functions that have default implementations

+ /// @{

+

+ // These functions have default implementations (but may be overridden for

+ // speed). Implementatons in tree/clusterable-classes.cc

+

+ /// Return the objective function of the combined object this + other.

+ virtual BaseFloat ObjfPlus(const Clusterable &other) const;

+ /// Return the objective function of the subtracted object this - other.

+ virtual BaseFloat ObjfMinus(const Clusterable &other) const;

+ /// Return the objective function decrease from merging the two

+ /// clusters, negated to be a positive number (or zero).

+ virtual BaseFloat Distance(const Clusterable &other) const;

+ /// @}

+

+};

+/// @} end of "ingroup clustering_group"

+

+} // end namespace kaldi

+

+#endif // KALDI_ITF_CLUSTERABLE_ITF_H_

+

+// itf/context-dep-itf.h

+

+// Copyright 2009-2011 Microsoft Corporation; Go Vivace Inc.

+

+// 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.

+

+

+#ifndef KALDI_ITF_CONTEXT_DEP_ITF_H_

+#define KALDI_ITF_CONTEXT_DEP_ITF_H_

+#include "base/kaldi-common.h"

+

+namespace kaldi {

+/// @ingroup tree_group

+/// @{

+

+/// context-dep-itf.h provides a link between

+/// the tree-building code in ../tree/, and the FST code in ../fstext/

+/// (particularly, ../fstext/context-dep.h). It is an abstract

+/// interface that describes an object that can map from a

+/// phone-in-context to a sequence of integer leaf-ids.

+class ContextDependencyInterface {

+ public:

+ /// ContextWidth() returns the value N (e.g. 3 for triphone models) that says how many phones

+ /// are considered for computing context.

+ virtual int ContextWidth() const = 0;

+

+ /// Central position P of the phone context, in 0-based numbering, e.g. P = 1 for typical

+ /// triphone system. We have to see if we can do without this function.

+ virtual int CentralPosition() const = 0;

+

+ /// The "new" Compute interface. For typical topologies,

+ /// pdf_class would be 0, 1, 2.

+ /// Returns success or failure; outputs the pdf-id.

+ ///

+ /// "Compute" is the main function of this interface, that takes a

+ /// sequence of N phones (and it must be N phones), possibly

+ /// including epsilons (symbol id zero) but only at positions other

+ /// than P [these represent unknown phone context due to end or

+ /// begin of sequence]. We do not insist that Compute must always

+ /// output (into stateseq) a nonempty sequence of states, but we

+ /// anticipate that stateseq will alyway be nonempty at output in

+ /// typical use cases. "Compute" returns false if expansion somehow

+ /// failed. Normally the calling code should raise an exception if

+ /// this happens. We can define a different interface later in

+ /// order to handle other kinds of information-- the underlying

+ /// data-structures from event-map.h are very flexible.

+ virtual bool Compute(const std::vector<int32> &phoneseq, int32 pdf_class,

+ int32 *pdf_id) const = 0;

+

+

+

+ /// NumPdfs() returns the number of acoustic pdfs (they are numbered 0.. NumPdfs()-1).

+ virtual int32 NumPdfs() const = 0;

+

+ virtual ~ContextDependencyInterface() {};

+ ContextDependencyInterface() {}

+

+ /// Returns pointer to new object which is copy of current one.

+ virtual ContextDependencyInterface *Copy() const = 0;

+ private:

+ KALDI_DISALLOW_COPY_AND_ASSIGN(ContextDependencyInterface);

+};

+/// @}

+} // namespace Kaldi

+

+

+#endif

+// itf/decodable-itf.h

+

+// Copyright 2009-2011 Microsoft Corporation; Saarland University;

+// Mirko Hannemann; Go Vivace Inc.;

+// 2013 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.

+

+#ifndef KALDI_ITF_DECODABLE_ITF_H_

+#define KALDI_ITF_DECODABLE_ITF_H_ 1

+#include "base/kaldi-common.h"

+

+namespace kaldi {

+/// @ingroup Interfaces

+/// @{

+

+

+/**

+ DecodableInterface provides a link between the (acoustic-modeling and

+ feature-processing) code and the decoder. The idea is to make this

+ interface as small as possible, and to make it as agnostic as possible about

+ the form of the acoustic model (e.g. don't assume the probabilities are a

+ function of just a vector of floats), and about the decoder (e.g. don't

+ assume it accesses frames in strict left-to-right order). For normal

+ models, without on-line operation, the "decodable" sub-class will just be a

+ wrapper around a matrix of features and an acoustic model, and it will

+ answer the question 'what is the acoustic likelihood for this index and this

+ frame?'.

+

+ For online decoding, where the features are coming in in real time, it is

+ important to understand the IsLastFrame() and NumFramesReady() functions.

+ There are two ways these are used: the old online-decoding code, in ../online/,

+ and the new online-decoding code, in ../online2/. In the old online-decoding

+ code, the decoder would do:

+ \code{.cc}

+ for (int frame = 0; !decodable.IsLastFrame(frame); frame++) {

+ // Process this frame

+ }

+ \endcode

+ and the the call to IsLastFrame would block if the features had not arrived yet.

+ The decodable object would have to know when to terminate the decoding. This

+ online-decoding mode is still supported, it is what happens when you call, for

+ example, LatticeFasterDecoder::Decode().

+

+ We realized that this "blocking" mode of decoding is not very convenient

+ because it forces the program to be multi-threaded and makes it complex to

+ control endpointing. In the "new" decoding code, you don't call (for example)

+ LatticeFasterDecoder::Decode(), you call LatticeFasterDecoder::InitDecoding(),

+ and then each time you get more features, you provide them to the decodable

+ object, and you call LatticeFasterDecoder::AdvanceDecoding(), which does

+ something like this:

+ \code{.cc}

+ while (num_frames_decoded_ < decodable.NumFramesReady()) {

+ // Decode one more frame [increments num_frames_decoded_]

+ }

+ \endcode

+ So the decodable object never has IsLastFrame() called. For decoding where

+ you are starting with a matrix of features, the NumFramesReady() function will

+ always just return the number of frames in the file, and IsLastFrame() will

+ return true for the last frame.

+

+ For truly online decoding, the "old" online decodable objects in ../online/ have a

+ "blocking" IsLastFrame() and will crash if you call NumFramesReady().

+ The "new" online decodable objects in ../online2/ return the number of frames

+ currently accessible if you call NumFramesReady(). You will likely not need

+ to call IsLastFrame(), but we implement it to only return true for the last

+ frame of the file once we've decided to terminate decoding.

+*/

+

+class DecodableInterface {

+ public:

+ /// Returns the log likelihood, which will be negated in the decoder.

+ /// The "frame" starts from zero. You should verify that IsLastFrame(frame-1)

+ /// returns false before calling this.

+ virtual BaseFloat LogLikelihood(int32 frame, int32 index) = 0;

+

+ /// Returns true if this is the last frame. Frames are zero-based, so the

+ /// first frame is zero. IsLastFrame(-1) will return false, unless the file

+ /// is empty (which is a case that I'm not sure all the code will handle, so

+ /// be careful). Caution: the behavior of this function in an online setting

+ /// is being changed somewhat. In future it may return false in cases where

+ /// we haven't yet decided to terminate decoding, but later true if we decide

+ /// to terminate decoding. The plan in future is to rely more on

+ /// NumFramesReady(), and in future, IsLastFrame() would always return false

+ /// in an online-decoding setting, and would only return true in a

+ /// decoding-from-matrix setting where we want to allow the last delta or LDA

+ /// features to be flushed out for compatibility with the baseline setup.

+ virtual bool IsLastFrame(int32 frame) const = 0;

+

+ /// The call NumFramesReady() will return the number of frames currently available

+ /// for this decodable object. This is for use in setups where you don't want the

+ /// decoder to block while waiting for input. This is newly added as of Jan 2014,

+ /// and I hope, going forward, to rely on this mechanism more than IsLastFrame to

+ /// know when to stop decoding.

+ virtual int32 NumFramesReady() const {

+ KALDI_ERR << "NumFramesReady() not implemented for this decodable type.";

+ return -1;

+ }

+

+ /// Returns the number of states in the acoustic model

+ /// (they will be indexed one-based, i.e. from 1 to NumIndices();

+ /// this is for compatibility with OpenFst.

+ virtual int32 NumIndices() const = 0;

+

+ virtual ~DecodableInterface() {}

+};

+/// @}

+} // namespace Kaldi

+

+#endif // KALDI_ITF_DECODABLE_ITF_H_

+// itf/online-feature-itf.h

+

+// Copyright 2013 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.

+

+#ifndef KALDI_ITF_ONLINE_FEATURE_ITF_H_

+#define KALDI_ITF_ONLINE_FEATURE_ITF_H_ 1

+#include "base/kaldi-common.h"

+#include "matrix/matrix-lib.h"

+

+namespace kaldi {

+/// @ingroup Interfaces

+/// @{

+

+/**

+ OnlineFeatureInterface is an interface for online feature processing (it is

+ also usable in the offline setting, but currently we're not using it for

+ that). This is for use in the online2/ directory, and it supersedes the

+ interface in ../online/online-feat-input.h. We have a slighty different

+ model that puts more control in the hands of the calling thread, and won't

+ involve waiting on semaphores in the decoding thread.

+

+ This interface only specifies how the object *outputs* the features.

+ How it obtains the features, e.g. from a previous object or objects of type

+ OnlineFeatureInterface, is not specified in the interface and you will

+ likely define new constructors or methods in the derived type to do that.

+

+ You should appreciate that this interface is designed to allow random

+ access to features, as long as they are ready. That is, the user

+ can call GetFrame for any frame less than NumFramesReady(), and when

+ implementing a child class you must not make assumptions about the

+ order in which the user makes these calls.

+*/

+

+class OnlineFeatureInterface {

+ public:

+ virtual int32 Dim() const = 0; /// returns the feature dimension.

+

+ /// Returns the total number of frames, since the start of the utterance, that

+ /// are now available. In an online-decoding context, this will likely

+ /// increase with time as more data becomes available.

+ virtual int32 NumFramesReady() const = 0;

+

+ /// Returns true if this is the last frame. Frame indices are zero-based, so the

+ /// first frame is zero. IsLastFrame(-1) will return false, unless the file

+ /// is empty (which is a case that I'm not sure all the code will handle, so

+ /// be careful). This function may return false for some frame if

+ /// we haven't yet decided to terminate decoding, but later true if we decide

+ /// to terminate decoding. This function exists mainly to correctly handle

+ /// end effects in feature extraction, and is not a mechanism to determine how

+ /// many frames are in the decodable object (as it used to be, and for backward

+ /// compatibility, still is, in the Decodable interface).

+ virtual bool IsLastFrame(int32 frame) const = 0;

+

+ /// Gets the feature vector for this frame. Before calling this for a given

+ /// frame, it is assumed that you called NumFramesReady() and it returned a

+ /// number greater than "frame". Otherwise this call will likely crash with

+ /// an assert failure. This function is not declared const, in case there is

+ /// some kind of caching going on, but most of the time it shouldn't modify

+ /// the class.

+ virtual void GetFrame(int32 frame, VectorBase<BaseFloat> *feat) = 0;

+

+ /// Virtual destructor. Note: constructors that take another member of

+ /// type OnlineFeatureInterface are not expected to take ownership of

+ /// that pointer; the caller needs to keep track of that manually.

+ virtual ~OnlineFeatureInterface() { }

+};

+

+

+/// Add a virtual class for "source" features such as MFCC or PLP or pitch

+/// features.

+class OnlineBaseFeature: public OnlineFeatureInterface {

+ public:

+ /// This would be called from the application, when you get more wave data.

+ /// Note: the sampling_rate is typically only provided so the code can assert

+ /// that it matches the sampling rate expected in the options.

+ virtual void AcceptWaveform(BaseFloat sampling_rate,

+ const VectorBase<BaseFloat> &waveform) = 0;

+

+ /// InputFinished() tells the class you won't be providing any

+ /// more waveform. This will help flush out the last few frames

+ /// of delta or LDA features (it will typically affect the return value

+ /// of IsLastFrame.

+ virtual void InputFinished() = 0;

+};

+

+

+/// @}

+} // namespace Kaldi

+

+#endif // KALDI_ITF_ONLINE_FEATURE_ITF_H_

+// itf/optimizable-itf.h

+

+// Copyright 2009-2011 Go Vivace Inc.; Microsoft Corporation; Georg Stemmer

+

+// 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.

+#ifndef KALDI_ITF_OPTIMIZABLE_ITF_H_

+#define KALDI_ITF_OPTIMIZABLE_ITF_H_

+

+#include "base/kaldi-common.h"

+#include "matrix/matrix-lib.h"

+

+namespace kaldi {

+/// @ingroup Interfaces

+/// @{

+

+/// OptimizableInterface provides

+/// a virtual class for optimizable objects.

+/// E.g. a class that computed a likelihood function and

+/// its gradient using some parameter

+/// that has to be optimized on data

+/// could inherit from it.

+template<class Real>

+class OptimizableInterface {

+ public:

+ /// computes gradient for a parameter params and returns it

+ /// in gradient_out

+ virtual void ComputeGradient(const Vector<Real> &params,

+ Vector<Real> *gradient_out) = 0;

+ /// computes the function value for a parameter params

+ /// and returns it

+ virtual Real ComputeValue(const Vector<Real> &params) = 0;

+

+ virtual ~OptimizableInterface() {}

+};

+/// @} end of "Interfaces"

+} // end namespace kaldi

+

+#endif

+// itf/options-itf.h

+

+// Copyright 2013 Tanel Alumae, Tallinn University of Technology

+

+// 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.

+

+#ifndef KALDI_ITF_OPTIONS_ITF_H_

+#define KALDI_ITF_OPTIONS_ITF_H_ 1

+#include "base/kaldi-common.h"

+

+namespace kaldi {

+

+class OptionsItf {

+ public:

+

+ virtual void Register(const std::string &name,

+ bool *ptr, const std::string &doc) = 0;

+ virtual void Register(const std::string &name,

+ int32 *ptr, const std::string &doc) = 0;

+ virtual void Register(const std::string &name,

+ uint32 *ptr, const std::string &doc) = 0;

+ virtual void Register(const std::string &name,

+ float *ptr, const std::string &doc) = 0;

+ virtual void Register(const std::string &name,

+ double *ptr, const std::string &doc) = 0;

+ virtual void Register(const std::string &name,

+ std::string *ptr, const std::string &doc) = 0;

+

+ virtual ~OptionsItf() {}

+};

+

+} // namespace Kaldi

+

+#endif // KALDI_ITF_OPTIONS_ITF_H_

+

+

+// matrix/cblas-wrappers.h

+

+// Copyright 2012 Johns Hopkins University (author: Daniel Povey);

+// Haihua Xu; Wei Shi

+

+// 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.

+#ifndef KALDI_MATRIX_CBLAS_WRAPPERS_H_

+#define KALDI_MATRIX_CBLAS_WRAPPERS_H_ 1

+

+

+#include <limits>

+#include "matrix/sp-matrix.h"

+#include "matrix/kaldi-vector.h"

+#include "matrix/kaldi-matrix.h"

+#include "matrix/matrix-functions.h"

+

+// Do not include this file directly. It is to be included

+// by .cc files in this directory.

+

+namespace kaldi {

+

+

+inline void cblas_Xcopy(const int N, const float *X, const int incX, float *Y,

+ const int incY) {

+ cblas_scopy(N, X, incX, Y, incY);

+}

+

+inline void cblas_Xcopy(const int N, const double *X, const int incX, double *Y,

+ const int incY) {

+ cblas_dcopy(N, X, incX, Y, incY);

+}

+

+

+inline float cblas_Xasum(const int N, const float *X, const int incX) {

+ return cblas_sasum(N, X, incX);

+}

+

+inline double cblas_Xasum(const int N, const double *X, const int incX) {

+ return cblas_dasum(N, X, incX);

+}

+

+inline void cblas_Xrot(const int N, float *X, const int incX, float *Y,

+ const int incY, const float c, const float s) {

+ cblas_srot(N, X, incX, Y, incY, c, s);

+}

+inline void cblas_Xrot(const int N, double *X, const int incX, double *Y,

+ const int incY, const double c, const double s) {

+ cblas_drot(N, X, incX, Y, incY, c, s);

+}

+inline float cblas_Xdot(const int N, const float *const X,

+ const int incX, const float *const Y,

+ const int incY) {

+ return cblas_sdot(N, X, incX, Y, incY);

+}

+inline double cblas_Xdot(const int N, const double *const X,

+ const int incX, const double *const Y,

+ const int incY) {

+ return cblas_ddot(N, X, incX, Y, incY);

+}

+inline void cblas_Xaxpy(const int N, const float alpha, const float *X,

+ const int incX, float *Y, const int incY) {

+ cblas_saxpy(N, alpha, X, incX, Y, incY);

+}

+inline void cblas_Xaxpy(const int N, const double alpha, const double *X,

+ const int incX, double *Y, const int incY) {

+ cblas_daxpy(N, alpha, X, incX, Y, incY);

+}

+inline void cblas_Xscal(const int N, const float alpha, float *data,

+ const int inc) {

+ cblas_sscal(N, alpha, data, inc);

+}

+inline void cblas_Xscal(const int N, const double alpha, double *data,

+ const int inc) {

+ cblas_dscal(N, alpha, data, inc);

+}

+inline void cblas_Xspmv(const float alpha, const int num_rows, const float *Mdata,

+ const float *v, const int v_inc,

+ const float beta, float *y, const int y_inc) {

+ cblas_sspmv(CblasRowMajor, CblasLower, num_rows, alpha, Mdata, v, v_inc, beta, y, y_inc);

+}

+inline void cblas_Xspmv(const double alpha, const int num_rows, const double *Mdata,

+ const double *v, const int v_inc,

+ const double beta, double *y, const int y_inc) {

+ cblas_dspmv(CblasRowMajor, CblasLower, num_rows, alpha, Mdata, v, v_inc, beta, y, y_inc);

+}

+inline void cblas_Xtpmv(MatrixTransposeType trans, const float *Mdata,

+ const int num_rows, float *y, const int y_inc) {

+ cblas_stpmv(CblasRowMajor, CblasLower, static_cast<CBLAS_TRANSPOSE>(trans),

+ CblasNonUnit, num_rows, Mdata, y, y_inc);

+}

+inline void cblas_Xtpmv(MatrixTransposeType trans, const double *Mdata,

+ const int num_rows, double *y, const int y_inc) {

+ cblas_dtpmv(CblasRowMajor, CblasLower, static_cast<CBLAS_TRANSPOSE>(trans),

+ CblasNonUnit, num_rows, Mdata, y, y_inc);

+}

+

+

+inline void cblas_Xtpsv(MatrixTransposeType trans, const float *Mdata,

+ const int num_rows, float *y, const int y_inc) {

+ cblas_stpsv(CblasRowMajor, CblasLower, static_cast<CBLAS_TRANSPOSE>(trans),

+ CblasNonUnit, num_rows, Mdata, y, y_inc);

+}

+inline void cblas_Xtpsv(MatrixTransposeType trans, const double *Mdata,

+ const int num_rows, double *y, const int y_inc) {

+ cblas_dtpsv(CblasRowMajor, CblasLower, static_cast<CBLAS_TRANSPOSE>(trans),

+ CblasNonUnit, num_rows, Mdata, y, y_inc);

+}

+

+// x = alpha * M * y + beta * x

+inline void cblas_Xspmv(MatrixIndexT dim, float alpha, const float *Mdata,

+ const float *ydata, MatrixIndexT ystride,

+ float beta, float *xdata, MatrixIndexT xstride) {

+ cblas_sspmv(CblasRowMajor, CblasLower, dim, alpha, Mdata,

+ ydata, ystride, beta, xdata, xstride);

+}

+inline void cblas_Xspmv(MatrixIndexT dim, double alpha, const double *Mdata,

+ const double *ydata, MatrixIndexT ystride,

+ double beta, double *xdata, MatrixIndexT xstride) {

+ cblas_dspmv(CblasRowMajor, CblasLower, dim, alpha, Mdata,

+ ydata, ystride, beta, xdata, xstride);

+}

+

+// Implements A += alpha * (x y' + y x'); A is symmetric matrix.

+inline void cblas_Xspr2(MatrixIndexT dim, float alpha, const float *Xdata,

+ MatrixIndexT incX, const float *Ydata, MatrixIndexT incY,

+ float *Adata) {

+ cblas_sspr2(CblasRowMajor, CblasLower, dim, alpha, Xdata,

+ incX, Ydata, incY, Adata);

+}

+inline void cblas_Xspr2(MatrixIndexT dim, double alpha, const double *Xdata,

+ MatrixIndexT incX, const double *Ydata, MatrixIndexT incY,

+ double *Adata) {

+ cblas_dspr2(CblasRowMajor, CblasLower, dim, alpha, Xdata,

+ incX, Ydata, incY, Adata);

+}

+

+// Implements A += alpha * (x x'); A is symmetric matrix.

+inline void cblas_Xspr(MatrixIndexT dim, float alpha, const float *Xdata,

+ MatrixIndexT incX, float *Adata) {

+ cblas_sspr(CblasRowMajor, CblasLower, dim, alpha, Xdata, incX, Adata);

+}

+inline void cblas_Xspr(MatrixIndexT dim, double alpha, const double *Xdata,

+ MatrixIndexT incX, double *Adata) {

+ cblas_dspr(CblasRowMajor, CblasLower, dim, alpha, Xdata, incX, Adata);

+}

+

+// sgemv,dgemv: y = alpha M x + beta y.

+inline void cblas_Xgemv(MatrixTransposeType trans, MatrixIndexT num_rows,

+ MatrixIndexT num_cols, float alpha, const float *Mdata,

+ MatrixIndexT stride, const float *xdata,

+ MatrixIndexT incX, float beta, float *ydata, MatrixIndexT incY) {

+ cblas_sgemv(CblasRowMajor, static_cast<CBLAS_TRANSPOSE>(trans), num_rows,

+ num_cols, alpha, Mdata, stride, xdata, incX, beta, ydata, incY);

+}

+inline void cblas_Xgemv(MatrixTransposeType trans, MatrixIndexT num_rows,

+ MatrixIndexT num_cols, double alpha, const double *Mdata,

+ MatrixIndexT stride, const double *xdata,

+ MatrixIndexT incX, double beta, double *ydata, MatrixIndexT incY) {

+ cblas_dgemv(CblasRowMajor, static_cast<CBLAS_TRANSPOSE>(trans), num_rows,

+ num_cols, alpha, Mdata, stride, xdata, incX, beta, ydata, incY);

+}

+

+// sgbmv, dgmmv: y = alpha M x + + beta * y.

+inline void cblas_Xgbmv(MatrixTransposeType trans, MatrixIndexT num_rows,

+ MatrixIndexT num_cols, MatrixIndexT num_below,

+ MatrixIndexT num_above, float alpha, const float *Mdata,

+ MatrixIndexT stride, const float *xdata,

+ MatrixIndexT incX, float beta, float *ydata, MatrixIndexT incY) {

+ cblas_sgbmv(CblasRowMajor, static_cast<CBLAS_TRANSPOSE>(trans), num_rows,

+ num_cols, num_below, num_above, alpha, Mdata, stride, xdata,

+ incX, beta, ydata, incY);

+}

+inline void cblas_Xgbmv(MatrixTransposeType trans, MatrixIndexT num_rows,

+ MatrixIndexT num_cols, MatrixIndexT num_below,

+ MatrixIndexT num_above, double alpha, const double *Mdata,

+ MatrixIndexT stride, const double *xdata,

+ MatrixIndexT incX, double beta, double *ydata, MatrixIndexT incY) {

+ cblas_dgbmv(CblasRowMajor, static_cast<CBLAS_TRANSPOSE>(trans), num_rows,

+ num_cols, num_below, num_above, alpha, Mdata, stride, xdata,

+ incX, beta, ydata, incY);

+}

+

+

+template<typename Real>

+inline void Xgemv_sparsevec(MatrixTransposeType trans, MatrixIndexT num_rows,

+ MatrixIndexT num_cols, Real alpha, const Real *Mdata,

+ MatrixIndexT stride, const Real *xdata,

+ MatrixIndexT incX, Real beta, Real *ydata,

+ MatrixIndexT incY) {

+ if (trans == kNoTrans) {

+ if (beta != 1.0) cblas_Xscal(num_rows, beta, ydata, incY);

+ for (MatrixIndexT i = 0; i < num_cols; i++) {

+ Real x_i = xdata[i * incX];

+ if (x_i == 0.0) continue;

+ // Add to ydata, the i'th column of M, times alpha * x_i

+ cblas_Xaxpy(num_rows, x_i * alpha, Mdata + i, stride, ydata, incY);

+ }

+ } else {

+ if (beta != 1.0) cblas_Xscal(num_cols, beta, ydata, incY);

+ for (MatrixIndexT i = 0; i < num_rows; i++) {

+ Real x_i = xdata[i * incX];

+ if (x_i == 0.0) continue;

+ // Add to ydata, the i'th row of M, times alpha * x_i

+ cblas_Xaxpy(num_cols, x_i * alpha,

+ Mdata + (i * stride), 1, ydata, incY);

+ }

+ }

+}

+

+inline void cblas_Xgemm(const float alpha,

+ MatrixTransposeType transA,

+ const float *Adata,

+ MatrixIndexT a_num_rows, MatrixIndexT a_num_cols, MatrixIndexT a_stride,

+ MatrixTransposeType transB,

+ const float *Bdata, MatrixIndexT b_stride,

+ const float beta,

+ float *Mdata,

+ MatrixIndexT num_rows, MatrixIndexT num_cols,MatrixIndexT stride) {

+ cblas_sgemm(CblasRowMajor, static_cast<CBLAS_TRANSPOSE>(transA),

+ static_cast<CBLAS_TRANSPOSE>(transB),

+ num_rows, num_cols, transA == kNoTrans ? a_num_cols : a_num_rows,

+ alpha, Adata, a_stride, Bdata, b_stride,

+ beta, Mdata, stride);

+}

+inline void cblas_Xgemm(const double alpha,

+ MatrixTransposeType transA,

+ const double *Adata,

+ MatrixIndexT a_num_rows, MatrixIndexT a_num_cols, MatrixIndexT a_stride,

+ MatrixTransposeType transB,

+ const double *Bdata, MatrixIndexT b_stride,

+ const double beta,

+ double *Mdata,

+ MatrixIndexT num_rows, MatrixIndexT num_cols,MatrixIndexT stride) {

+ cblas_dgemm(CblasRowMajor, static_cast<CBLAS_TRANSPOSE>(transA),

+ static_cast<CBLAS_TRANSPOSE>(transB),

+ num_rows, num_cols, transA == kNoTrans ? a_num_cols : a_num_rows,

+ alpha, Adata, a_stride, Bdata, b_stride,

+ beta, Mdata, stride);

+}

+

+

+inline void cblas_Xsymm(const float alpha,

+ MatrixIndexT sz,

+ const float *Adata,MatrixIndexT a_stride,

+ const float *Bdata,MatrixIndexT b_stride,

+ const float beta,

+ float *Mdata, MatrixIndexT stride) {

+ cblas_ssymm(CblasRowMajor, CblasLeft, CblasLower, sz, sz, alpha, Adata,

+ a_stride, Bdata, b_stride, beta, Mdata, stride);

+}

+inline void cblas_Xsymm(const double alpha,

+ MatrixIndexT sz,

+ const double *Adata,MatrixIndexT a_stride,

+ const double *Bdata,MatrixIndexT b_stride,

+ const double beta,

+ double *Mdata, MatrixIndexT stride) {

+ cblas_dsymm(CblasRowMajor, CblasLeft, CblasLower, sz, sz, alpha, Adata,

+ a_stride, Bdata, b_stride, beta, Mdata, stride);

+}

+// ger: M += alpha x y^T.

+inline void cblas_Xger(MatrixIndexT num_rows, MatrixIndexT num_cols, float alpha,

+ const float *xdata, MatrixIndexT incX, const float *ydata,

+ MatrixIndexT incY, float *Mdata, MatrixIndexT stride) {

+ cblas_sger(CblasRowMajor, num_rows, num_cols, alpha, xdata, 1, ydata, 1,

+ Mdata, stride);

+}

+inline void cblas_Xger(MatrixIndexT num_rows, MatrixIndexT num_cols, double alpha,

+ const double *xdata, MatrixIndexT incX, const double *ydata,

+ MatrixIndexT incY, double *Mdata, MatrixIndexT stride) {

+ cblas_dger(CblasRowMajor, num_rows, num_cols, alpha, xdata, 1, ydata, 1,

+ Mdata, stride);

+}

+

+// syrk: symmetric rank-k update.

+// if trans==kNoTrans, then C = alpha A A^T + beta C

+// else C = alpha A^T A + beta C.

+// note: dim_c is dim(C), other_dim_a is the "other" dimension of A, i.e.

+// num-cols(A) if kNoTrans, or num-rows(A) if kTrans.

+// We only need the row-major and lower-triangular option of this, and this

+// is hard-coded.

+inline void cblas_Xsyrk (

+ const MatrixTransposeType trans, const MatrixIndexT dim_c,

+ const MatrixIndexT other_dim_a, const float alpha, const float *A,

+ const MatrixIndexT a_stride, const float beta, float *C,

+ const MatrixIndexT c_stride) {

+ cblas_ssyrk(CblasRowMajor, CblasLower, static_cast<CBLAS_TRANSPOSE>(trans),

+ dim_c, other_dim_a, alpha, A, a_stride, beta, C, c_stride);

+}

+

+inline void cblas_Xsyrk(