kaldifst

add_self_loops

kaldifst.add_self_loops(fst: _kaldifst.StdMutableFst, isyms: List[int], osyms: List[int]) → None

AddSelfLoops is a function you will probably want to use alongside PreDeterminize, to add self-loops to any FSTs that you compose on the left hand side of the one modified by PreDeterminize.

This function inserts loops with “special symbols” [e.g. #0, #1] into an FST. This is done at each final state and each state with non-epsilon output symbols on at least one arc out of it. This is to ensure that these symbols, when inserted into the input side of an FST we will compose with on the right, can “pass through” this FST.

At input, isyms and osyms must be vectors of the same size n, corresponding to symbols that currently do not exist in ‘fst’. For each state in n that has non-epsilon symbols on the output side of arcs leaving it, or which is a final state, this function inserts n self-loops with unit weight and one of the n pairs of symbols on its input and output.

Caution

The input FST is modified in-place.

Parameters

• ifst – The input FST.

• isyms – A list of input symbols.

• osyms – A list of output symbols. Must satisfy len(isyms) == len(osyms).

Returns

Return None.

Example 1: Add self loops to a transducer

Listing 10 Add self loops to a transducer.

import graphviz

import kaldifst

s = """
0 1 a p
1
1 2 b q
2 3 c r
3 4 f t
3 0 d s
5 0 f t
"""


sym1 = kaldifst.SymbolTable(name="sym1")
sym1.add_symbol("a", 1)
sym1.add_symbol("b", 2)
sym1.add_symbol("c", 3)
sym1.add_symbol("d", 4)
sym1.add_symbol("f", 5)
sym1.add_symbol("#0", 6)
sym1.add_symbol("#1", 7)

sym2 = kaldifst.SymbolTable(name="sym2")
sym2.add_symbol("p", 1)
sym2.add_symbol("q", 2)
sym2.add_symbol("r", 3)
sym2.add_symbol("s", 4)
sym2.add_symbol("t", 5)
sym2.add_symbol("#0", 6)
sym2.add_symbol("#1", 7)

fst = kaldifst.compile(s=s, acceptor=False, isymbols=sym1, osymbols=sym2)

fst.input_symbols = sym1
fst.output_symbols = sym2

fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="fst.svg")

kaldifst.add_self_loops(fst, isyms=[6, 7], osyms=[6, 7])

fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="fst-add-self-loops.svg")

Fig. 10 Visualization of fst.svg (before connect)

Fig. 11 Visualization of fst-add-self-loops.svg (after calling add_self_loops())

arcsort

kaldifst.arcsort(in_out: _kaldifst.StdMutableFst, sort_type: str = 'ilabel') → None

Sort arcs of an FST in-place.

See also https://www.openfst.org/twiki/bin/view/FST/ArcSortDoc

Caution

The FST is modified in-place.

Parameters

• in_out – An acceptor or a transducer. It is modified in-place.

• sort_type – Comparison method, one of “ilabel”, “olabel”

Returns

Return None.

Example 1: Sort an acceptor

Listing 11 Sort an acceptor

import kaldifst

s1 = """
0 1 1
0 1 3
0 1 2
0 2 5
0 2 4
1 2 2
1 2 3
1 2 1
2
"""
fsa = kaldifst.compile(s=s1, acceptor=True)
fsa_dot = kaldifst.draw(fsa, acceptor=True, portrait=True)
print(fsa_dot)

import graphviz

source = graphviz.Source(fsa_dot)
source.render(outfile="acceptor.svg")

kaldifst.arcsort(fsa)
fsa_dot = kaldifst.draw(fsa, acceptor=True, portrait=True)

source2 = graphviz.Source(fsa_dot)
source2.render(outfile="sorted.svg")

Fig. 12 Visualization of acceptor.svg (before sort)

Fig. 13 Visualization of sorted.svg (after sort)

Example 2: Sort a transducer by ilabel

Listing 12 Sort a transducer by ilabel

import kaldifst

s1 = """
0 1 1 4
0 1 3 5
0 1 2 3
0 2 5 2
0 2 4 1
1 2 2 3
1 2 3 1
1 2 1 2
2
"""
fst = kaldifst.compile(s=s1, acceptor=False)
fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
print(fst_dot)

import graphviz

source = graphviz.Source(fst_dot)
source.render(outfile="transducer1.svg")

kaldifst.arcsort(fst, sort_type="ilabel")
fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
source = graphviz.Source(fst_dot)
source.render(outfile="sorted-transducer-ilabel.svg")

Fig. 14 Visualization of transducer1.svg (before sort)

Fig. 15 Visualization of sorted-transducer-ilabel.svg (after sort)

Example 3: Sort a transducer by olabel

Listing 13 Sort a transducer by olabel

import kaldifst

s1 = """
0 1 1 4
0 1 3 5
0 1 2 3
0 2 5 2
0 2 4 1
1 2 2 3
1 2 3 1
1 2 1 2
2
"""
fst = kaldifst.compile(s=s1, acceptor=False)
fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
print(fst_dot)

import graphviz

source = graphviz.Source(fst_dot)
source.render(outfile="transducer2.svg")

kaldifst.arcsort(fst, sort_type="olabel")
fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
source = graphviz.Source(fst_dot)
source.render(outfile="sorted-transducer-olabel.svg")

Fig. 16 Visualization of transducer2.svg (before sort)

Fig. 17 Visualization of sorted-transducer-olabel.svg (after sort)

compile

kaldifst.compile(s: str, acceptor: bool = False, arc_type: str = 'standard', fst_type: str = 'vector', isymbols: object = None, osymbols: object = None, ssymbols: object = None, keep_isymbols: bool = False, keep_osymbols: bool = False, keep_state_numbering: bool = False, allow_negative_labels: bool = False) → object

Create transducer/acceptor from simple text format.

Parameters

• s – A string containing the text format of the FST.

• acceptor – Input in acceptor format.

• arc_type – Output arc type.

• fst_type – Output FST type.

• isymbols – Input label symbol table.

• osymbols – Output label symbol table.

• ssymbols – State label symbol table.

• keep_isymbols – Store input label symbol table with FST.

• keep_osymbols – Store output label symbol table with FST.

• keep_state_numbering – Do not renumber input states.

• allow_negative_labels – Allow negative labels (not recommended; may cause conflicts)

Returns

Return an FST.

Example 1: Create an acceptor

Listing 14 Create an acceptor

import kaldifst

s1 = """
0 1 1 1.5
1 2 2 2.5
2 0.3
"""
fsa = kaldifst.compile(s=s1, acceptor=True)
fsa_dot = kaldifst.draw(fsa, acceptor=True, portrait=True)
print(fsa_dot)

import graphviz

source = graphviz.Source(fsa_dot)
source.render(outfile="acceptor1.svg")

Fig. 18 Visualization of acceptor1.svg

Example 2: Create an acceptor with symbol table

Listing 15 Create an acceptor with symbol table

import kaldifst

s1 = """
0 1 a 1.5
1 2 b 2.5
2 0.3
"""
isym = kaldifst.SymbolTable(name="An arbitrary name")
isym.add_symbol("a", 1)
isym.add_symbol("b", 2)
fsa = kaldifst.compile(s=s1, acceptor=True, isymbols=isym, keep_isymbols=False)
fsa.input_symbols = isym
fsa_dot = kaldifst.draw(fsa, acceptor=True, portrait=True)
print(fsa_dot)

import graphviz

source = graphviz.Source(fsa_dot)
source.render(outfile="acceptor2.svg")

Fig. 19 Visualization of acceptor2.svg

Example 3: Create a transducer

Listing 16 Create a transducer

import kaldifst

s1 = """
0 1 1 10 1.5
1 2 2 20 2.5
2 0.3
"""
fst = kaldifst.compile(s=s1, acceptor=False)
fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
print(fst_dot)

import graphviz

source = graphviz.Source(fst_dot)
source.render(outfile="transducer1.svg")

Fig. 20 Visualization of transducer1.svg

Example 4: Create a transducer with symbol table

Listing 17 Create a transducer with symbol table

import kaldifst

s1 = """
0 1 a A 1.5
1 2 b B 2.5
2 0.3
"""
isym = kaldifst.SymbolTable(name="An arbitrary name")
isym.add_symbol("a", 1)
isym.add_symbol("b", 2)

osym = kaldifst.SymbolTable(name="Another arbitrary name")
osym.add_symbol("A", 1)
osym.add_symbol("B", 2)

fst = kaldifst.compile(
    s=s1,
    acceptor=False,
    isymbols=isym,
    osymbols=osym,
    keep_isymbols=False,
    keep_osymbols=False,
)
fst.input_symbols = isym
fst.output_symbols = osym
fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
print(fst_dot)

import graphviz

source = graphviz.Source(fst_dot)
source.render(outfile="transducer2.svg")

Fig. 21 Visualization of transducer2.svg

compose

kaldifst.compose(fst1: _kaldifst.StdFst, fst2: _kaldifst.StdFst, match_side: str = 'left', compose_filter: str = 'sequence', connect: bool = True) → _kaldifst.StdMutableFst

Compose two FSTs.

This operation computes the composition of two transducers. If A transduces string x to y with weight a and B transduces y to z with weight b, then their composition transduces string x to z with weight a ⊗ b.

See also https://www.openfst.org/twiki/bin/view/FST/ComposeDoc

Caution

The output labels of the first transducer or the input labels of the second transducer must be sorted.

Parameters

• fst1 – The first FST.

• fst2 – The second FST.

• match_side – Defaults to left.

• compose_filter – Composition filter, one of: “alt_sequence”, “auto”, “match”, “no_match”, “null”, “sequence”, “trivial”.

• connect – Trim output.

Returns

Return the composition result.

Example 1: Compose two transducers.

Listing 18 Compose two transducers

import graphviz

import kaldifst

s1 = """
0 1 a q 1
0 2 a r 2.5
1 1 c s 1
1 0
2 2.5
"""

sym1 = kaldifst.SymbolTable(name="sym1")
sym1.add_symbol("a", 1)
sym1.add_symbol("c", 2)

sym2 = kaldifst.SymbolTable(name="sym2")
sym2.add_symbol("q", 1)
sym2.add_symbol("r", 2)
sym2.add_symbol("s", 3)

a = kaldifst.compile(s=s1, acceptor=False, isymbols=sym1, osymbols=sym2)
a.input_symbols = sym1
a.output_symbols = sym2

s2 = """
0 1 q f 1
0 2 r h 3
1 2 s g 2.5
2 2 s j 1.5
2 2
"""

sym3 = kaldifst.SymbolTable(name="sym3")
sym3.add_symbol("f", 1)
sym3.add_symbol("g", 2)
sym3.add_symbol("h", 3)
sym3.add_symbol("j", 4)

b = kaldifst.compile(s=s2, acceptor=False, isymbols=sym2, osymbols=sym3)
b.input_symbols = sym2
b.output_symbols = sym3

a_dot = kaldifst.draw(a, acceptor=False, portrait=True)
a_source = graphviz.Source(a_dot)
a_source.render(outfile="a.svg")

b_dot = kaldifst.draw(b, acceptor=False, portrait=True)
b_source = graphviz.Source(b_dot)
b_source.render(outfile="b.svg")

# sort b by ilabel. It is sorted in-place
kaldifst.arcsort(b, sort_type="ilabel")

c = kaldifst.compose(a, b)
c_dot = kaldifst.draw(c, acceptor=False, portrait=True)
c_source = graphviz.Source(c_dot)
c_source.render(outfile="c.svg")

Fig. 22 The first transducer a.

Fig. 23 The second transducer b

Fig. 24 The composition result c.

compose_context

kaldifst.compose_context(disambig_syms: List[int], context_width: int, central_position: int, ifst: _kaldifst.StdVectorFst, project_ifst: bool = False) → Tuple[_kaldifst.StdVectorFst, List[List[int]]]

compose_context composes efficiently with a context fst that it generates.

Without disambig_syms specified, it assumes that all input symbols of ifst are phones. It adds the subsequential symbol itself (it does not appear in the output so doesn’t need to be specified by the user). the disambig_syms is a list of disambiguation symbols on the LHS of ifst. The symbols on the LHS of out.fst are indexes into the ilabels.list file, which is a kaldi-format file containing a vector<vector<int32>>, which specifies what the labels mean in terms of windows of symbols.

Parameters

• disambig_syms – List of disambiguation symbols, e.g. the integer ids of #0, #1, #2 … in the phones.txt.

• context_width – Size of context window, e.g. 3 for triphone.

• central_position – Central position in phonetic context window (zero-based index), e.g. 1 for triphone.

• ifst – The FST we are composing with C (e.g. LG.fst),

• project_ifst – This is intended only to be set to true in the program ‘fstmakecontextfst’… if true, it will project on the input after adding the subsequential loop to ‘ifst’, which allows us to reconstruct the context fst C.fst.

Returns

• ofst: The resulting fst

• ilabels, a List[List[int]]

Return type

Return a tuple containing (ofst, ilabels), where

connect

kaldifst.connect(in_out: _kaldifst.StdMutableFst) → None

This operation trims an FST, removing states and arcs that are not on successful paths.

Caution

The input FST is modified in-place.

See also https://www.openfst.org/twiki/bin/view/FST/ConnectDoc

Parameters

in_out – The FST to be connected. Note it is modified in-place.

Returns

Return None.

Example 1: Connect a transducer

Listing 19 Connect a transducer

import graphviz

import kaldifst

s = """
0 1 a p
1
1 2 b q
2 3 c r
3 4 f t
3 0 d s
5 0 f t
"""


sym1 = kaldifst.SymbolTable(name="sym1")
sym1.add_symbol("a", 1)
sym1.add_symbol("b", 2)
sym1.add_symbol("c", 3)
sym1.add_symbol("d", 4)
sym1.add_symbol("f", 5)

sym2 = kaldifst.SymbolTable(name="sym2")
sym2.add_symbol("p", 1)
sym2.add_symbol("q", 2)
sym2.add_symbol("r", 3)
sym2.add_symbol("s", 4)
sym2.add_symbol("t", 5)

fst = kaldifst.compile(s=s, acceptor=False, isymbols=sym1, osymbols=sym2)

fst.input_symbols = sym1
fst.output_symbols = sym2

fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="fst.svg")

kaldifst.connect(fst)

fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="fst-connect.svg")

Fig. 25 Visualization of fst.svg (before connect)

Fig. 26 Visualization of fst-connect.svg (after connect)

determinize

kaldifst.determinize(ifst: _kaldifst.StdFst, delta: float = 0.0009765625, det_type: str = 'functional', increment_subsequential_label: bool = False, nstate: int = - 1, subsequential_label: int = 0, weight: str = '') → _kaldifst.StdVectorFst

This operation determinizes a weighted transducer.

The result will be an equivalent FST that has the property that no state has two transitions with the same input label. For this algorithm, epsilon transitions are treated as regular symbols (cf. RmEpsilon).

See also https://www.openfst.org/twiki/bin/view/FST/DeterminizeDoc

Parameters

• ifst – The input FST.

• delta – Comparison/quantization delta.

• det_type – Type of determinization: “functional”, “nonfunctional”, “disambiguate”.

• increment_subsequential_label – Increment subsequential_label to obtain distinct labels for subsequential arcs at a given state

• nstate – State number threshold

• subsequential_label – Input label of arc corresponding to residual final output when producing a subsequential transducer

• weight – Weight threshold

Returns

Return the determinized FST.

Example 1: Determinize a transducer

Listing 20 Determinize a transducer.

import graphviz

import kaldifst

s = """
0 1 a p 1
0 2 a q 2
0 1 eps q 3
1 3 c r 5
1 3 c r 4
2 3 d s 6
3 0
"""

sym1 = kaldifst.SymbolTable(name="sym1")
sym1.add_symbol("eps", 0)
sym1.add_symbol("a", 1)
sym1.add_symbol("c", 2)
sym1.add_symbol("d", 3)

sym2 = kaldifst.SymbolTable(name="sym2")
sym2.add_symbol("eps", 0)
sym2.add_symbol("p", 1)
sym2.add_symbol("q", 2)
sym2.add_symbol("r", 3)
sym2.add_symbol("s", 4)

fst = kaldifst.compile(s=s, acceptor=False, isymbols=sym1, osymbols=sym2)
fst.input_symbols = sym1
fst.output_symbols = sym2

fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="transducer.svg")

fst = kaldifst.determinize(fst)

fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="transducer2.svg")

Fig. 27 Visualization of transducer.svg (before determinization)

Fig. 28 Visualization of transducer2.svg (after determinization)

determinize_star

kaldifst.determinize_star(in_out: _kaldifst.StdVectorFst, delta: float = 0.0009765625, max_states: int = - 1, use_log: bool = False) → bool

Removes epsilons and determinizes in one step.

See also https://github.com/kaldi-asr/kaldi/blob/master/src/fstbin/fstdeterminizestar.cc

Caution

The input FST is modified in-place.

Parameters

• in_out – The input/output FST. Note it is modified in-place.

• delta – Delta value used to determine equivalence of weights.

• max_states – Maximum number of states in determinized FST before it will abort.

• use_log – Determinize in log semiring.

Returns

this function will return False if determinization completed normally, and true if it was stopped early by reaching the ‘max-states’ limit, and a partial FST was generated.

Return type

The return status is un-intuitive

Example 1: Determinize a transducer

Listing 21 Determinize a transducer.

import graphviz

import kaldifst

s = """
0 1 a p 1
0 2 a q 2
0 1 eps q 3
1 3 c r 5
1 3 c r 4
2 3 d s 6
3 0
"""

sym1 = kaldifst.SymbolTable(name="sym1")
sym1.add_symbol("eps", 0)
sym1.add_symbol("a", 1)
sym1.add_symbol("c", 2)
sym1.add_symbol("d", 3)

sym2 = kaldifst.SymbolTable(name="sym2")
sym2.add_symbol("eps", 0)
sym2.add_symbol("p", 1)
sym2.add_symbol("q", 2)
sym2.add_symbol("r", 3)
sym2.add_symbol("s", 4)

fst = kaldifst.compile(s=s, acceptor=False, isymbols=sym1, osymbols=sym2)
fst.input_symbols = sym1
fst.output_symbols = sym2

fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="transducer.svg")

kaldifst.determinize_star(fst)

fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="transducer2.svg")

Fig. 29 Visualization of transducer.svg (before determinization)

Fig. 30 Visualization of transducer2.svg (after determinization)

divide

kaldifst.divide(*args, **kwargs)

Overloaded function.

1. divide(arg0: _kaldifst.TropicalWeight, arg1: _kaldifst.TropicalWeight) -> _kaldifst.TropicalWeight

2. divide(arg0: _kaldifst.LatticeWeight, arg1: _kaldifst.LatticeWeight) -> _kaldifst.LatticeWeight

draw

kaldifst.draw(*args, **kwargs)

Overloaded function.

1. draw(fst: _kaldifst.StdFst, acceptor: bool = False, isymbols: object = None, osymbols: object = None, ssymbols: object = None, numeric: bool = False, precision: int = 5, float_format: str = ‘g’, show_weight_one: bool = False, title: str = ‘’, portrait: bool = False, vertical: bool = False, fontsize: int = 14, height: float = 11, width: float = 8.5, nodesep: float = 0.25, ranksep: float = 0.4, allow_negative_labels: bool = False) -> str

Prints FSTs in dot text format.

Hint

You can use the Python package graphviz to visualize it.

You can also post the dot format output to https://dreampuf.github.io/GraphvizOnline/ to visualize it within your browser. You can also share the URL to others.

Parameters

• fst – The FST to be printed.

• acceptor – Input in acceptor format

• isymbols – Input label symbol table

• osymbols – Output label symbol table

• ssymbols – State label symbol table

• numeric – Print numeric labels

• precision – Set precision (number of char/float)

• float_format – Floating-point format, one of: “e”, “f”, or “g”

• show_weight_one – Print/draw arc weights and final weights equal to Weight::One()

• title – Set figure title

• portrait – Portrait mode (def: landscape)

• vertical – Draw bottom-to-top instead of left-to-right

• fontsize – Set fontsize

• height – Set height

• width – Set width

• nodesep – Set minimum separation between nodes (see dot documentation)

• ranksep – Set minimum separation between ranks (see dot documentation)

• allow_negative_labels – Allow negative labels (not recommended; may cause conflicts)

Returns

Return a string.

Example 1: Draw a transducer

Listing 22 Draw a transducer.

import graphviz

import kaldifst

s1 = """
0 1 a q 1
0 2 a r 2.5
1 1 c s 1
1 0
2 2.5
"""

sym1 = kaldifst.SymbolTable(name="sym1")
sym1.add_symbol("a", 1)
sym1.add_symbol("c", 2)

sym2 = kaldifst.SymbolTable(name="sym2")
sym2.add_symbol("q", 1)
sym2.add_symbol("r", 2)
sym2.add_symbol("s", 3)

fst = kaldifst.compile(s=s1, acceptor=False, isymbols=sym1, osymbols=sym2)
fst.input_symbols = sym1
fst.output_symbols = sym2

fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
with open("fst_dot.txt", "w") as f:
    f.write(fst_dot)

fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="fst.svg")

Listing 23 fst_dot.txt

digraph FST {
rankdir = LR;
size = "8.5,11";
center = 1;
orientation = Portrait;
ranksep = "0.4";
nodesep = "0.25";
0 [label = "0", shape = circle, style = bold, fontsize = 14]
	0 -> 1 [label = "a:q/1", fontsize = 14];
	0 -> 2 [label = "a:r/2.5", fontsize = 14];
1 [label = "1", shape = doublecircle, style = solid, fontsize = 14]
	1 -> 1 [label = "c:s/1", fontsize = 14];
2 [label = "2/2.5", shape = doublecircle, style = solid, fontsize = 14]
}

Fig. 31 Visualization of fst.svg

2. draw(fst: _kaldifst.LatticeFst, acceptor: bool = False, isymbols: object = None, osymbols: object = None, ssymbols: object = None, numeric: bool = False, precision: int = 5, float_format: str = ‘g’, show_weight_one: bool = False, title: str = ‘’, portrait: bool = False, vertical: bool = False, fontsize: int = 14, height: float = 11, width: float = 8.5, nodesep: float = 0.25, ranksep: float = 0.4, allow_negative_labels: bool = False) -> str

Prints FSTs in dot text format.

Hint

You can use the Python package graphviz to visualize it.

You can also post the dot format output to https://dreampuf.github.io/GraphvizOnline/ to visualize it within your browser. You can also share the URL to others.

Parameters

• fst – The FST to be printed.

• acceptor – Input in acceptor format

• isymbols – Input label symbol table

• osymbols – Output label symbol table

• ssymbols – State label symbol table

• numeric – Print numeric labels

• precision – Set precision (number of char/float)

• float_format – Floating-point format, one of: “e”, “f”, or “g”

• show_weight_one – Print/draw arc weights and final weights equal to Weight::One()

• title – Set figure title

• portrait – Portrait mode (def: landscape)

• vertical – Draw bottom-to-top instead of left-to-right

• fontsize – Set fontsize

• height – Set height

• width – Set width

• nodesep – Set minimum separation between nodes (see dot documentation)

• ranksep – Set minimum separation between ranks (see dot documentation)

• allow_negative_labels – Allow negative labels (not recommended; may cause conflicts)

Returns

Return a string.

Example 1: Draw a transducer

Listing 24 Draw a transducer.

import graphviz

import kaldifst

s1 = """
0 1 a q 1
0 2 a r 2.5
1 1 c s 1
1 0
2 2.5
"""

sym1 = kaldifst.SymbolTable(name="sym1")
sym1.add_symbol("a", 1)
sym1.add_symbol("c", 2)

sym2 = kaldifst.SymbolTable(name="sym2")
sym2.add_symbol("q", 1)
sym2.add_symbol("r", 2)
sym2.add_symbol("s", 3)

fst = kaldifst.compile(s=s1, acceptor=False, isymbols=sym1, osymbols=sym2)
fst.input_symbols = sym1
fst.output_symbols = sym2

fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
with open("fst_dot.txt", "w") as f:
    f.write(fst_dot)

fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="fst.svg")

Listing 25 fst_dot.txt

digraph FST {
rankdir = LR;
size = "8.5,11";
center = 1;
orientation = Portrait;
ranksep = "0.4";
nodesep = "0.25";
0 [label = "0", shape = circle, style = bold, fontsize = 14]
	0 -> 1 [label = "a:q/1", fontsize = 14];
	0 -> 2 [label = "a:r/2.5", fontsize = 14];
1 [label = "1", shape = doublecircle, style = solid, fontsize = 14]
	1 -> 1 [label = "c:s/1", fontsize = 14];
2 [label = "2/2.5", shape = doublecircle, style = solid, fontsize = 14]
}

Fig. 32 Visualization of fst.svg

equal_align

kaldifst.equal_align(ifst: _kaldifst.StdVectorFst, length: int, rand_seed: int, num_retries: int = 10) → Tuple[bool, _kaldifst.StdVectorFst]

Get a random linear path from an FST.

Parameters

• ifst – The input fst.

• length – Path length of the output fst. If the ilabel of an arc is 0, then this arc does not contribute to the total path length of the output fst.

• rand_seed – A seed for random selecting arcs out of each state.

• num_retries – After trying this number but failed to generate a valid fst, it would return False.

Returns

• succeeded, True if we successfully found a path.

• fst, the output fst.

Return type

Return a tuple containing

Example 1: Equal align

Listing 26 Code for equal_align

import graphviz

import kaldifst

s1 = """
0 0 e E 0.3
0 1 a A 1
0 1 b B 2.5
1 2 <eps> <eps> 0.3
1 2 <eps> <eps> 0.4
1 1 f F 0.03
2 2 g G 0.8
2 3 h H 0.12
3
"""

sym1 = kaldifst.SymbolTable(name="sym1")
sym1.add_symbol("<eps>", 0)
sym1.add_symbol("a", 1)
sym1.add_symbol("b", 2)
sym1.add_symbol("c", 3)
sym1.add_symbol("d", 4)
sym1.add_symbol("e", 5)
sym1.add_symbol("f", 6)
sym1.add_symbol("g", 7)
sym1.add_symbol("h", 8)

sym2 = kaldifst.SymbolTable(name="sym2")
sym2.add_symbol("<eps>", 0)
sym2.add_symbol("A", 1)
sym2.add_symbol("B", 2)
sym2.add_symbol("C", 3)
sym2.add_symbol("D", 4)
sym2.add_symbol("E", 5)
sym2.add_symbol("F", 6)
sym2.add_symbol("G", 7)
sym2.add_symbol("H", 8)

fst = kaldifst.compile(s=s1, acceptor=False, isymbols=sym1, osymbols=sym2)

fst.input_symbols = sym1
fst.output_symbols = sym2

fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="input.svg")

succeeded, first = kaldifst.equal_align(
    ifst=fst, length=4, rand_seed=3, num_retries=10
)
assert succeeded is True
first.input_symbols = sym1
first.output_symbols = sym1

first_dot = kaldifst.draw(first, acceptor=False, portrait=True)
first_source = graphviz.Source(first_dot)
first_source.render(outfile="first.svg")

succeeded, second = kaldifst.equal_align(
    ifst=fst, length=5, rand_seed=10, num_retries=10
)
assert succeeded is True
second.input_symbols = sym1
second.output_symbols = sym2

second_dot = kaldifst.draw(second, acceptor=False, portrait=True)
second_source = graphviz.Source(second_dot)
second_source.render(outfile="second.svg")

Fig. 33 Visualization of input.svg

Fig. 34 Visualization of first.svg

Fig. 35 Visualization of second.svg

get_linear_symbol_sequence

kaldifst.get_linear_symbol_sequence(*args, **kwargs)

Overloaded function.

1. get_linear_symbol_sequence(fst: _kaldifst.StdFst) -> Tuple[bool, List[int], List[int], _kaldifst.TropicalWeight]

get_linear_symbol_sequence gets the symbol sequence from a linear FST. If the FST is not just a linear sequence, it returns false. If it is a linear sequence (including the empty FST), it returns true. In this case it outputs the symbol

Parameters

fst – The input fst.

Returns

• succeeded, bool, true if it succeeded.

• isymbols_out, List[int], containing non-zero input symbols

• osymbols_out, List[int], containing non-zero output symbols

• total_weight_out, float, the total weight

Return type

Return a tuple containing

Example 1: get_linear_symbol_sequence

Listing 27 Code for get_linear_symbol_sequence

import graphviz

import kaldifst

s = """
0 1 0 2 0.5
1 2 1 3 0.8
2 3 3 5 0.7
3 4 9 0 0.1
4 0.2
"""


fst = kaldifst.compile(s=s, acceptor=False)

(
    succeeded,
    isymbols_out,
    osymbols_out,
    total_weight,
) = kaldifst.get_linear_symbol_sequence(fst)
assert succeeded is True
assert isymbols_out == [1, 3, 9]
assert osymbols_out == [2, 3, 5]

assert (
    abs(total_weight.value - (0.5 + 0.8 + 0.7 + 0.1 + 0.2)) < 1e-3
), total_weight.value

2. get_linear_symbol_sequence(fst: _kaldifst.LatticeFst) -> Tuple[bool, List[int], List[int], _kaldifst.LatticeWeight]

get_linear_symbol_sequence gets the symbol sequence from a linear FST. If the FST is not just a linear sequence, it returns false. If it is a linear sequence (including the empty FST), it returns true. In this case it outputs the symbol

Parameters

fst – The input fst.

Returns

• succeeded, bool, true if it succeeded.

• isymbols_out, List[int], containing non-zero input symbols

• osymbols_out, List[int], containing non-zero output symbols

• total_weight_out, float, the total weight

Return type

Return a tuple containing

Example 1: get_linear_symbol_sequence

Listing 28 Code for get_linear_symbol_sequence

import graphviz

import kaldifst

s = """
0 1 0 2 0.5
1 2 1 3 0.8
2 3 3 5 0.7
3 4 9 0 0.1
4 0.2
"""


fst = kaldifst.compile(s=s, acceptor=False)

(
    succeeded,
    isymbols_out,
    osymbols_out,
    total_weight,
) = kaldifst.get_linear_symbol_sequence(fst)
assert succeeded is True
assert isymbols_out == [1, 3, 9]
assert osymbols_out == [2, 3, 5]

assert (
    abs(total_weight.value - (0.5 + 0.8 + 0.7 + 0.1 + 0.2)) < 1e-3
), total_weight.value

info

kaldifst.info(fst: _kaldifst.StdFst, arc_filter: str = 'any', info_type: str = 'auto', pipe: bool = False, test_properties: bool = False, fst_verify: bool = True) → None

–arc_filter: type = string, default = “any” Arc filter: one of: “any”, “epsilon”, “iepsilon”, “oepsilon”; this only affects the counts of (co)accessible states, connected states, and (strongly) connected components –fst_verify: type = bool, default = true Verify FST sanity –info_type: type = string, default = “auto” Info format: one of: “auto”, “long”, “short” –pipe: type = bool, default = false Send info to stderr, input to stdout –test_properties: type = bool, default = true Compute property values (if unknown to FST)

invert

kaldifst.invert(in_out: _kaldifst.StdMutableFst) → None

This operation inverts the transduction corresponding to an FST by exchanging the FST’s input and output labels.

See also https://www.openfst.org/twiki/bin/view/FST/InvertDoc

Caution

The FST is modified in-place.

Parameters

in_out – A transducer. It is modified in-place.

Returns

Return None.

Example Invert a transducer

Listing 29 Invert a transducer

#!/usr/bin/env python3

import graphviz

import kaldifst

s = """
0 1 a y 1
0 1 b x 3
1 1 d v 7
1 2 c w 5
2 3 f u 9
3 2
"""
isym = kaldifst.SymbolTable.from_str(
    """
        a 1
        b 2
        c 3
        d 4
        f 5
"""
)

osym = kaldifst.SymbolTable.from_str(
    """
        x 1
        y 2
        u 3
        w 4
        v 5
"""
)

fst = kaldifst.compile(
    s,
    acceptor=False,
    isymbols=isym,
    osymbols=osym,
    keep_isymbols=True,
    keep_osymbols=True,
)


fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="before-invert.svg")

kaldifst.invert(fst)

fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="after-invert.svg")

Fig. 36 Visualization of before-invert.svg

Fig. 37 Visualization of after-invert.svg

lattice_scale

kaldifst.lattice_scale(lmwt: float, acwt: float) → List[List[float]]

Return a diagonal scale matrix with specified LM scale lmwt and AM scale amwt.

Note that the diagonal matrix is a list of list, e.g., [[lmwt, 0], [0, acwt]].

Parameters

• lmwt – Scale for language model scores.

• acwt – Scale for acoustic likelihoods.

Returns

• A list-of-list containing [[lmwt, 0], [0, acwt]].

Example 1: Return a matrix with lmwt=0.1, acwt=10.0

Listing 30 Return a matrix with lmwt=0.1, acwt=10.0

#!/usr/bin/env python3

import kaldifst

m = kaldifst.lattice_scale(lmwt=0.1, acwt=10.0)
assert m == [[0.1, 0.0], [0.0, 10.0]], m

make_linear_acceptor

kaldifst.make_linear_acceptor(labels: List[int]) → _kaldifst.StdVectorFst

Creates unweighted linear acceptor from symbol sequence.

Parameters

labels – A list of symbol IDs.

Returns

Return a linear acceptor. Actually, it returns a transducer whose ilabel == olabel for each arc.

Example 1: Build a linear acceptor

Listing 31 Example of make_linear_acceptor()

import graphviz

import kaldifst


sym1 = kaldifst.SymbolTable(name="sym1")
sym1.add_symbol("e", 1)
sym1.add_symbol("h", 2)
sym1.add_symbol("l", 3)
sym1.add_symbol("o", 4)


fst = kaldifst.make_linear_acceptor([2, 1, 3, 3, 4])

fst.input_symbols = sym1
fst.output_symbols = sym1

fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="acceptor.svg")

Fig. 38 Visualization of acceptor.svg

minimize

kaldifst.minimize(in_out: _kaldifst.StdMutableFst, delta: float = 1e-06, allow_nondet: bool = False) → None

This operation performs the minimization of deterministic weighted automata and transducers.

See also https://www.openfst.org/twiki/bin/view/FST/MinimizeDoc.

Caution

The FST is modified in-place.

Parameters

• in_out – An acceptor or a transducer. It is modified in-place.

• delta – Comparison/quantization delta

• allow_nondet – type = bool, default = false True to minimize non-deterministic FSTs

Returns

Return None.

Example 1: Minimize an acceptor

Listing 32 Minimize an acceptor

#!/usr/bin/env python3

import graphviz

import kaldifst

s = """
0 1 a 2
0 1 b 2
0 1 c 3
0 2 d 3
0 2 f 1
1 3 f 3
1 3 g 2
3 1
2 4 f 5
2 4 g 4
4 3
"""

isym = kaldifst.SymbolTable.from_str(
    """
        a 1
        b 2
        c 3
        d 4
        f 5
        g 6
"""
)

fst = kaldifst.compile(
    s,
    acceptor=True,
    isymbols=isym,
    keep_isymbols=True,
)

fst_dot = kaldifst.draw(fst, acceptor=True, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="acceptor.svg")

kaldifst.minimize(fst)

fst_dot = kaldifst.draw(fst, acceptor=True, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="acceptor-minimized.svg")

Fig. 39 Visualization of acceptor.svg (before minimize)

Fig. 40 Visualization of acceptor-minimized.svg (after minimize)

Example 2: Minimize a transducer

Listing 33 Minimize a transducer

#!/usr/bin/env python3

import graphviz

import kaldifst

s = """
0 1 a a 2
0 1 b a 2
0 1 c a 3
0 2 d a 3
0 2 f a 1
1 3 f b 3
1 3 g b 2
3 1
2 4 f c 5
2 4 g c 4
4 3
"""

isym = kaldifst.SymbolTable.from_str(
    """
        a 1
        b 2
        c 3
        d 4
        f 5
        g 6
"""
)

osym = kaldifst.SymbolTable.from_str(
    """
        a 1
        b 2
        c 3
"""
)


fst = kaldifst.compile(
    s,
    acceptor=False,
    isymbols=isym,
    osymbols=osym,
    keep_isymbols=True,
    keep_osymbols=True,
)

fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="transducer.svg")

kaldifst.minimize(fst)

fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="transducer-minimized.svg")

Fig. 41 Visualization of transducer.svg (before minimize)

Fig. 42 Visualization of transducer-minimized.svg (after minimize)

minimize_encoded

kaldifst.minimize_encoded(in_out: _kaldifst.StdMutableFst, delta: float = 0.0009765625) → None

Minimizes after encoding; applicable to all FSTs.

Its implementation is from Kaldi:

Map(fst, QuantizeMapper<Arc>(delta));
EncodeMapper<Arc> encoder(kEncodeLabels | kEncodeWeights, ENCODE);
Encode(fst, &encoder);
internal::AcceptorMinimize(fst);
Decode(fst, encoder);

See also https://github.com/kaldi-asr/kaldi/blob/master/src/fstbin/fstminimizeencoded.cc.

Caution

The FST is modified in-place.

Parameters

• in_out – An acceptor or a transducer. It is modified in-place.

• delta – Comparison/quantization delta

Returns

Return None.

Example 1: Minimize encode an acceptor

Listing 34 Minimize encode an acceptor

#!/usr/bin/env python3

import graphviz

import kaldifst

s = """
0 1 a 2
0 1 b 2
0 1 c 3
0 2 d 3
0 2 f 1
1 3 f 3
1 3 g 2
3 1
2 4 f 5
2 4 g 4
4 3
"""

isym = kaldifst.SymbolTable.from_str(
    """
        a 1
        b 2
        c 3
        d 4
        f 5
        g 6
"""
)

fst = kaldifst.compile(
    s,
    acceptor=True,
    isymbols=isym,
    keep_isymbols=True,
)

fst_dot = kaldifst.draw(fst, acceptor=True, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="acceptor.svg")

fst.write("acceptor.fst")
kaldifst.minimize_encoded(fst)

fst_dot = kaldifst.draw(fst, acceptor=True, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="acceptor-minimize-encoded.svg")

Fig. 43 Visualization of acceptor.svg (before minimize_encoded)

Fig. 44 Visualization of acceptor-minimize-encoded.svg (after minimize_encoded)

Example 2: Minimize encode a transducer

Listing 35 Minimize encode a transducer

#!/usr/bin/env python3

import graphviz

import kaldifst

s = """
0 1 a a 2
0 1 b a 2
0 1 c a 3
0 2 d a 3
0 2 f a 1
1 3 f b 3
1 3 g b 2
3 1
2 4 f c 5
2 4 g c 4
4 3
"""

isym = kaldifst.SymbolTable.from_str(
    """
        a 1
        b 2
        c 3
        d 4
        f 5
        g 6
"""
)

osym = kaldifst.SymbolTable.from_str(
    """
        a 1
        b 2
        c 3
"""
)


fst = kaldifst.compile(
    s,
    acceptor=False,
    isymbols=isym,
    osymbols=osym,
    keep_isymbols=True,
    keep_osymbols=True,
)

fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="transducer.svg")

kaldifst.minimize_encoded(fst)

fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="transducer-minimize-encoded.svg")

Fig. 45 Visualization of transducer.svg (before minimize_encoded)

Fig. 46 Visualization of transducer-minimize-encoded.svg (after minimize encoded)

plus

kaldifst.plus(*args, **kwargs)

Overloaded function.

1. plus(arg0: _kaldifst.TropicalWeight, arg1: _kaldifst.TropicalWeight) -> _kaldifst.TropicalWeight

2. plus(arg0: _kaldifst.LatticeWeight, arg1: _kaldifst.LatticeWeight) -> _kaldifst.LatticeWeight

reverse

kaldifst.reverse(ifst: _kaldifst.StdFst, require_superinitial: bool = True) → _kaldifst.StdVectorFst

This operation reverses an FST. If A transduces string x to y with weight a, then the reverse of A transduces the reverse of x to the reverse of y with weight a.Reverse().

See also https://www.openfst.org/twiki/bin/view/FST/ReverseDoc.

Parameters

• ifst – The input FST.

• require_superinitial – True to create a superinitial state.

Returns

Return the reversed FST.

Example 1 Revert an acceptor (require_superinitial=True)

Listing 36 Revert an acceptor using require_superinitial=True

#!/usr/bin/env python3

import graphviz

import kaldifst

s = """
0 0 a 2
0 1 a 1
1 3
1 2 b 3
1 2 b 4
2 2 d 5
2 3 d 6
3 3 f 2
3 2
"""
isym = kaldifst.SymbolTable.from_str(
    """
        eps 0
        a 1
        b 2
        c 3
        d 4
        f 5
"""
)

fst = kaldifst.compile(
    s,
    acceptor=True,
    isymbols=isym,
    keep_isymbols=True,
)

fst_dot = kaldifst.draw(fst, acceptor=True, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="acceptor-before-reverse.svg")

fst = kaldifst.reverse(fst, require_superinitial=True)

fst_dot = kaldifst.draw(fst, acceptor=True, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="acceptor-after-reverse.svg")

Fig. 47 Visualization of acceptor-before-reverse.svg

Fig. 48 Visualization of acceptor-after-reverse.svg using require_superinitial=True

Example 2 Revert an acceptor (require_superinitial=False)

Listing 37 Revert an acceptor using require_superinitial=False

#!/usr/bin/env python3

import graphviz

import kaldifst

s = """
0 0 a 2
0 1 a 1
1 3
1 2 b 3
1 2 b 4
2 2 d 5
2 3 d 6
3 3 f 2
3 2
"""
isym = kaldifst.SymbolTable.from_str(
    """
        eps 0
        a 1
        b 2
        c 3
        d 4
        f 5
"""
)

fst = kaldifst.compile(
    s,
    acceptor=True,
    isymbols=isym,
    keep_isymbols=True,
)

fst_dot = kaldifst.draw(fst, acceptor=True, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="acceptor-before-reverse-2.svg")

fst = kaldifst.reverse(fst, require_superinitial=False)

fst_dot = kaldifst.draw(fst, acceptor=True, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="acceptor-after-reverse-2.svg")

Fig. 49 Visualization of acceptor-before-reverse-2.svg

Fig. 50 Visualization of acceptor-after-reverse-2.svg using require_superinitial=False

Example 3 Revert a transducer (require_superinitial=False)

Listing 38 Revert a transducer using require_superinitial=True

#!/usr/bin/env python3

import graphviz

import kaldifst

s = """
0 1 a a
1 2 b b
1 3 c c
2 4 eps eps
3 4 eps eps
4
"""
isym = kaldifst.SymbolTable.from_str(
    """
        eps 0
        a 1
        b 2
        c 3
"""
)

fst = kaldifst.compile(
    s,
    acceptor=False,
    isymbols=isym,
    osymbols=isym,
    keep_isymbols=True,
    keep_osymbols=True,
)

fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="transducer-before-reverse.svg")

fst = kaldifst.reverse(fst, require_superinitial=True)

fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="transducer-after-reverse.svg")

Fig. 51 Visualization of transducer-before-reverse.svg

Fig. 52 Visualization of transducer-after-reverse.svg using require_superinitial=True

Example 4 Revert a transducer (require_superinitial=False)

Listing 39 Revert a transducer using require_superinitial=False

#!/usr/bin/env python3

import graphviz

import kaldifst

s = """
0 1 a a
1 2 b b
1 3 c c
2 4 eps eps
3 4 eps eps
4
"""
isym = kaldifst.SymbolTable.from_str(
    """
        eps 0
        a 1
        b 2
        c 3
"""
)

fst = kaldifst.compile(
    s,
    acceptor=False,
    isymbols=isym,
    osymbols=isym,
    keep_isymbols=True,
    keep_osymbols=True,
)

fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="transducer-before-reverse-2.svg")

fst = kaldifst.reverse(fst, require_superinitial=False)

fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="transducer-after-reverse-2.svg")

Fig. 53 Visualization of transducer-before-reverse-2.svg

Fig. 54 Visualization of transducer-after-reverse-2.svg using require_superinitial=False

rmepsilon

kaldifst.rmepsilon(in_out: _kaldifst.StdMutableFst, connect: bool = True, delta: float = 1e-06, nstate: int = - 1, queue_type: str = 'auto', weight: str = '') → None

This operation removes epsilon-transitions (when both the input and output label are an epsilon) from a transducer. The result will be an equivalent FST that has no such epsilon transitions.

See also https://www.openfst.org/twiki/bin/view/FST/RmEpsilonDoc

Caution

The FST is modified in-place.

Parameters

• in_out – An FST. It is modified in-place.

• connect – Trim output

• delta – Comparison/quantization delta

• nstate – State number threshold

• queue_type – Queue type: one of: “auto”, “fifo”, “lifo”, “shortest”, “state”, “top”

• weight – Weight threshold

Returns

Return None.

Example Remove epsilon of a transducer

Listing 40 Remove epsilon of transducer

#!/usr/bin/env python3

import graphviz

import kaldifst

s = """
0 1 eps eps 1
1 2 a eps 2
1 2 eps p 3
1 2 eps eps 4
2 2 eps eps 5
2 3 eps eps 6
3 7
"""
isym = kaldifst.SymbolTable.from_str(
    """
        eps 0
        a 1
"""
)

osym = kaldifst.SymbolTable.from_str(
    """
        eps 0
        p 1
"""
)

fst = kaldifst.compile(
    s,
    acceptor=False,
    isymbols=isym,
    osymbols=osym,
    keep_isymbols=True,
    keep_osymbols=True,
)


fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="transducer.svg")

kaldifst.rmepsilon(fst)

fst_dot = kaldifst.draw(fst, acceptor=False, portrait=True)
fst_source = graphviz.Source(fst_dot)
fst_source.render(outfile="transducer-after-rmepsilon.svg")

Fig. 55 Visualization of transducer.svg

Fig. 56 Visualization of transducer-after-rmepsilon.svg

shortest_path

kaldifst.shortest_path(*args, **kwargs)

Overloaded function.

1. shortest_path(fst: _kaldifst.StdFst, n: int = 1) -> _kaldifst.StdVectorFst

This operation produces an FST containing the n-shortest paths in the input FST.

The n -shortest paths are the n -lowest weight paths w.r.t. the natural semiring order. The single path that can be read from the ith of at most n transitions leaving the initial state of the resulting FST is the ith shortest path.

See also https://www.openfst.org/twiki/bin/view/FST/ShortestPathDoc.

Parameters

• n – Size of n-best.

• unique – Return only distinct strings. (NB: must be acceptor; epsilons treated as regular symbols)

Returns

Return a VectorFst containing n paths.

Example 1: StdVectorFst

Listing 41 ShortestPath for a StdVectorFst

#!/usr/bin/env python3

import graphviz

import kaldifst

s1 = """
0 1 a 0.1
0 2 b 0.1
1 3 c 0.4
1 3 d 0.2
2 3 c 0.3
2 3 d 0.2
3 0
"""

sym1 = kaldifst.SymbolTable(name="sym1")
sym1.add_symbol("eps", 0)
sym1.add_symbol("a", 1)
sym1.add_symbol("b", 2)
sym1.add_symbol("c", 3)
sym1.add_symbol("d", 4)

a = kaldifst.compile(s=s1, acceptor=True, isymbols=sym1)
a.input_symbols = sym1

a_dot = kaldifst.draw(a, acceptor=True, portrait=True)
a_source = graphviz.Source(a_dot)
a_source.render(outfile="vector-fst.svg")

nbest_1 = kaldifst.shortest_path(a, n=1)
nbest_1_dot = kaldifst.draw(nbest_1, acceptor=True, portrait=True)
nbest_1_source = graphviz.Source(nbest_1_dot)
nbest_1_source.render(outfile="vector-fst-1best.svg")

nbest_2 = kaldifst.shortest_path(a, n=2)
nbest_2_dot = kaldifst.draw(nbest_2, acceptor=True, portrait=True)
nbest_2_source = graphviz.Source(nbest_2_dot)
nbest_2_source.render(outfile="vector-fst-2best.svg")

nbest_3 = kaldifst.shortest_path(a, n=3)
nbest_3_dot = kaldifst.draw(nbest_3, acceptor=True, portrait=True)
nbest_3_source = graphviz.Source(nbest_3_dot)
nbest_3_source.render(outfile="vector-fst-3best.svg")

Fig. 57 Visualization of vector-fst.svg

Fig. 58 Visualization of vector-fst-1best.svg

Fig. 59 Visualization of vector-fst-2best.svg

Fig. 60 Visualization of vector-fst-3best.svg

Example 2: Lattice

Listing 42 ShortestPath for a Lattice

Fig. 61 Visualization of lattice.svg

Fig. 62 Visualization of lattice-nbest.svg

2. shortest_path(fst: _kaldifst.LatticeFst, n: int = 1) -> _kaldifst.Lattice

This operation produces an FST containing the n-shortest paths in the input FST.

The n -shortest paths are the n -lowest weight paths w.r.t. the natural semiring order. The single path that can be read from the ith of at most n transitions leaving the initial state of the resulting FST is the ith shortest path.

See also https://www.openfst.org/twiki/bin/view/FST/ShortestPathDoc.

Parameters

• n – Size of n-best.

• unique – Return only distinct strings. (NB: must be acceptor; epsilons treated as regular symbols)

Returns

Return a VectorFst containing n paths.

Example 1: StdVectorFst

Listing 43 ShortestPath for a StdVectorFst

#!/usr/bin/env python3

import graphviz

import kaldifst

s1 = """
0 1 a 0.1
0 2 b 0.1
1 3 c 0.4
1 3 d 0.2
2 3 c 0.3
2 3 d 0.2
3 0
"""

sym1 = kaldifst.SymbolTable(name="sym1")
sym1.add_symbol("eps", 0)
sym1.add_symbol("a", 1)
sym1.add_symbol("b", 2)
sym1.add_symbol("c", 3)
sym1.add_symbol("d", 4)

a = kaldifst.compile(s=s1, acceptor=True, isymbols=sym1)
a.input_symbols = sym1

a_dot = kaldifst.draw(a, acceptor=True, portrait=True)
a_source = graphviz.Source(a_dot)
a_source.render(outfile="vector-fst.svg")

nbest_1 = kaldifst.shortest_path(a, n=1)
nbest_1_dot = kaldifst.draw(nbest_1, acceptor=True, portrait=True)
nbest_1_source = graphviz.Source(nbest_1_dot)
nbest_1_source.render(outfile="vector-fst-1best.svg")

nbest_2 = kaldifst.shortest_path(a, n=2)
nbest_2_dot = kaldifst.draw(nbest_2, acceptor=True, portrait=True)
nbest_2_source = graphviz.Source(nbest_2_dot)
nbest_2_source.render(outfile="vector-fst-2best.svg")

nbest_3 = kaldifst.shortest_path(a, n=3)
nbest_3_dot = kaldifst.draw(nbest_3, acceptor=True, portrait=True)
nbest_3_source = graphviz.Source(nbest_3_dot)
nbest_3_source.render(outfile="vector-fst-3best.svg")

Fig. 63 Visualization of vector-fst.svg

Fig. 64 Visualization of vector-fst-1best.svg

Fig. 65 Visualization of vector-fst-2best.svg

Fig. 66 Visualization of vector-fst-3best.svg

Example 2: Lattice

Listing 44 ShortestPath for a Lattice

Fig. 67 Visualization of lattice.svg

Fig. 68 Visualization of lattice-nbest.svg

times

kaldifst.times(*args, **kwargs)

Overloaded function.

1. times(arg0: _kaldifst.TropicalWeight, arg1: _kaldifst.TropicalWeight) -> _kaldifst.TropicalWeight

2. times(arg0: _kaldifst.LatticeWeight, arg1: _kaldifst.LatticeWeight) -> _kaldifst.LatticeWeight

ArcIterator

done

ArcIterator.done

flags

ArcIterator.flags

position

ArcIterator.position

value

ArcIterator.value

FloatWeight

value

FloatWeight.value

Lattice

Please refer to Introduction to Lattice for usage.

copy

Lattice.copy(self: _kaldifst.LatticeFst, safe: bool = False) → _kaldifst.LatticeFst

1. The copying is constant time if safe = false or if safe = true and is on an otherwise unaccessed FST.

(2) If safe = true, the copy is thread-safe in that the original and copy can be safely accessed (but not necessarily mutated) by separate threads. For some FST types, ‘Copy(true)’ should only be called on an FST that has not otherwise been accessed. Behavior is otherwise undefined.

(3) If a MutableFst is copied and then mutated, then the original is unmodified and vice versa (often by a copy-on-write on the initial mutation, which may not be constant time).

Warning

To get a deep copy of an FST, e.g., a deep copy of Lattice lat1, please use:

lat2 = kaldifst.Lattice(lat1)

To get deep copy of StdVectorFst fst1, please use

fst2 = kaldifst.StdVectorFst(fst1)

input_symbols

Lattice.input_symbols

is_ilabel_sorted

Lattice.is_ilabel_sorted

is_olabel_sorted

Lattice.is_olabel_sorted

num_states

Lattice.num_states

output_symbols

Lattice.output_symbols

start

Lattice.start

type

Lattice.type

LatticeArc

__init__

LatticeArc.__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: _kaldifst.LatticeArc) -> None

2. __init__(self: _kaldifst.LatticeArc, ilabel: int, olabel: int, weight: _kaldifst.LatticeWeight, nextstate: int) -> None

3. __init__(self: _kaldifst.LatticeArc, ilabel: int, olabel: int, weight: float, nextstate: int) -> None

ilabel

LatticeArc.ilabel

nextstate

LatticeArc.nextstate

olabel

LatticeArc.olabel

weight

LatticeArc.weight

LatticeWeight

value1

The graph cost.

LatticeWeight.value1

value2

The acoustic cost.

LatticeWeight.value2

RandomAccessVectorFstReader

is_open

RandomAccessVectorFstReader.is_open

Return True if it is opened; return False otherwise.

Return type

bool

SequentialVectorFstReader

done

SequentialVectorFstReader.done

Return type

bool

is_open

SequentialVectorFstReader.is_open

Return True if it is opened; return False otherwise.

Return type

bool

key

SequentialVectorFstReader.key

Return type

str

value

SequentialVectorFstReader.value

Return type

Any

StateIterator

done

StateIterator.done

value

StateIterator.value

StdArc

__init__

StdArc.__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: _kaldifst.StdArc) -> None

2. __init__(self: _kaldifst.StdArc, ilabel: int, olabel: int, weight: _kaldifst.TropicalWeight, nextstate: int) -> None

3. __init__(self: _kaldifst.StdArc, ilabel: int, olabel: int, weight: float, nextstate: int) -> None

ilabel

StdArc.ilabel

nextstate

StdArc.nextstate

olabel

StdArc.olabel

weight

StdArc.weight

StdConstFst

copy

StdConstFst.copy(self: _kaldifst.StdFst, safe: bool = False) → _kaldifst.StdFst

1. The copying is constant time if safe = false or if safe = true and is on an otherwise unaccessed FST.

(2) If safe = true, the copy is thread-safe in that the original and copy can be safely accessed (but not necessarily mutated) by separate threads. For some FST types, ‘Copy(true)’ should only be called on an FST that has not otherwise been accessed. Behavior is otherwise undefined.

(3) If a MutableFst is copied and then mutated, then the original is unmodified and vice versa (often by a copy-on-write on the initial mutation, which may not be constant time).

Warning

To get a deep copy of an FST, e.g., a deep copy of Lattice lat1, please use:

lat2 = kaldifst.Lattice(lat1)

To get deep copy of StdVectorFst fst1, please use

fst2 = kaldifst.StdVectorFst(fst1)

input_symbols

StdConstFst.input_symbols

Returns input label symbol table; return nullptr if not specified.

is_ilabel_sorted

StdConstFst.is_ilabel_sorted

is_olabel_sorted

StdConstFst.is_olabel_sorted

num_states

StdConstFst.num_states

output_symbols

StdConstFst.output_symbols

Returns output label symbol table; return nullptr if not specified.

start

StdConstFst.start

type

StdConstFst.type

StdFst

copy

StdFst.copy(self: _kaldifst.StdFst, safe: bool = False) → _kaldifst.StdFst

1. The copying is constant time if safe = false or if safe = true and is on an otherwise unaccessed FST.

(2) If safe = true, the copy is thread-safe in that the original and copy can be safely accessed (but not necessarily mutated) by separate threads. For some FST types, ‘Copy(true)’ should only be called on an FST that has not otherwise been accessed. Behavior is otherwise undefined.

(3) If a MutableFst is copied and then mutated, then the original is unmodified and vice versa (often by a copy-on-write on the initial mutation, which may not be constant time).

Warning

To get a deep copy of an FST, e.g., a deep copy of Lattice lat1, please use:

lat2 = kaldifst.Lattice(lat1)

To get deep copy of StdVectorFst fst1, please use

fst2 = kaldifst.StdVectorFst(fst1)

input_symbols

StdFst.input_symbols

Returns input label symbol table; return nullptr if not specified.

is_ilabel_sorted

StdFst.is_ilabel_sorted

is_olabel_sorted

StdFst.is_olabel_sorted

output_symbols

StdFst.output_symbols

Returns output label symbol table; return nullptr if not specified.

start

StdFst.start

type

StdFst.type

StdVectorFst

copy

StdVectorFst.copy(self: _kaldifst.StdFst, safe: bool = False) → _kaldifst.StdFst

1. The copying is constant time if safe = false or if safe = true and is on an otherwise unaccessed FST.

(2) If safe = true, the copy is thread-safe in that the original and copy can be safely accessed (but not necessarily mutated) by separate threads. For some FST types, ‘Copy(true)’ should only be called on an FST that has not otherwise been accessed. Behavior is otherwise undefined.

(3) If a MutableFst is copied and then mutated, then the original is unmodified and vice versa (often by a copy-on-write on the initial mutation, which may not be constant time).

Warning

To get a deep copy of an FST, e.g., a deep copy of Lattice lat1, please use:

lat2 = kaldifst.Lattice(lat1)

To get deep copy of StdVectorFst fst1, please use

fst2 = kaldifst.StdVectorFst(fst1)

input_symbols

StdVectorFst.input_symbols

is_ilabel_sorted

StdVectorFst.is_ilabel_sorted

is_olabel_sorted

StdVectorFst.is_olabel_sorted

num_states

StdVectorFst.num_states

output_symbols

StdVectorFst.output_symbols

start

StdVectorFst.start

type

StdVectorFst.type

SymbolTable

add_symbol

SymbolTable.add_symbol(*args, **kwargs)

Overloaded function.

1. add_symbol(self: _kaldifst.SymbolTable, symbol: str, key: int) -> int

Adds a symbol with given key to table. A symbol table also keeps track of the last available key (highest key value in the symbol table).

2. add_symbol(self: _kaldifst.SymbolTable, symbol: str) -> int

Adds a symbol to the table. The associated value key is automatically assigned by the symbol table.

find

SymbolTable.find(*args, **kwargs)

Overloaded function.

1. find(self: _kaldifst.SymbolTable, key: int) -> str

Returns the string associated with the key; if the key is out ofrange (<0, >max), returns an empty string.

2. find(self: _kaldifst.SymbolTable, symbol: str) -> int

Returns the key associated with the symbol; if the symbol does not exist, kNoSymbol is returned.

3. find(self: _kaldifst.SymbolTable, symbol: str) -> int

Returns the key associated with the symbol; if the symbol does not exist, kNoSymbol is returned.

check_sum

SymbolTable.check_sum

Return the label-agnostic MD5 check-sum for this table. All new symbols added to the table will result in an updated checksum. Deprecated.

labeled_check_sum

SymbolTable.labeled_check_sum

Same as check_sum, but returns an label-dependent version.

name

SymbolTable.name

TextNormalizer

TropicalWeight

value

TropicalWeight.value

VectorFstWriter

write

VectorFstWriter.write(key, value)

Write an item.

Parameters

• key (str) – The key for the item.

• value (Any) – The value for the item. Its type depends on the actual writer class.

Return type

None

is_open

VectorFstWriter.is_open

Return True if it is opened; return False otherwise.

Return type

bool