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.

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")

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")

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.

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")

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.

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)

convert_nbest_to_vector

kaldifst.convert_nbest_to_vector(*args, **kwargs)

Overloaded function.

convert_nbest_to_vector(fst: _kaldifst.StdFst) -> List[_kaldifst.StdVectorFst]

This function converts an FST with a special structure, which is output by the OpenFst functions ShortestPath and RandGen, and converts them into a list of separate FSTs. This special structure is that the only state that has more than one (arcs-out or final-prob) is the start state.

Parameters: fst – The input fst, which should be returned by shortestpath.
Returns: Return a list of linear FSTs.

Example for a StdVectorFst

Listing 20 convert_nbest_to_vector 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_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")

nbest_list = kaldifst.convert_nbest_to_vector(nbest_3)
for b in nbest_list:
    b.input_symbols = a.input_symbols
    b.output_symbols = a.output_symbols

nbest_list_0_dot = kaldifst.draw(nbest_list[0], acceptor=True, portrait=True)
nbest_list_0_source = graphviz.Source(nbest_list_0_dot)
nbest_list_0_source.render(outfile="vector-fst-3best-0.svg")

nbest_list_1_dot = kaldifst.draw(nbest_list[1], acceptor=True, portrait=True)
nbest_list_1_source = graphviz.Source(nbest_list_1_dot)
nbest_list_1_source.render(outfile="vector-fst-3best-1.svg")

nbest_list_2_dot = kaldifst.draw(nbest_list[2], acceptor=True, portrait=True)
nbest_list_2_source = graphviz.Source(nbest_list_2_dot)
nbest_list_2_source.render(outfile="vector-fst-3best-2.svg")

Fig. 27 Visualization of vector-fst.svg

Fig. 28 Visualization of vector-fst-3best.svg

Fig. 29 Visualization of vector-fst-3best-0.svg

Fig. 30 Visualization of vector-fst-3best-1.svg

Fig. 31 Visualization of vector-fst-3best-2.svg

convert_nbest_to_vector(fst: _kaldifst.LatticeFst) -> List[_kaldifst.Lattice]

This function converts an FST with a special structure, which is output by the OpenFst functions ShortestPath and RandGen, and converts them into a list of separate FSTs. This special structure is that the only state that has more than one (arcs-out or final-prob) is the start state.

Parameters: fst – The input fst, which should be returned by shortestpath.
Returns: Return a list of linear FSTs.

Example for a Lattice

Listing 21 convert_nbest_to_vector for a Lattice

#!/usr/bin/env python3

import graphviz

import kaldifst

fst = kaldifst.Lattice()
s0 = fst.add_state()
s1 = fst.add_state()
s2 = fst.add_state()
s3 = fst.add_state()

fst.start = s0
fst.add_arc(
    state=s0,
    arc=kaldifst.LatticeArc(
        ilabel=1,
        olabel=1,
        weight=kaldifst.LatticeWeight(graph_cost=0.02, acoustic_cost=0.08),
        nextstate=s1,
    ),
)

fst.add_arc(
    state=s0,
    arc=kaldifst.LatticeArc(
        ilabel=2,
        olabel=2,
        weight=kaldifst.LatticeWeight(graph_cost=0.03, acoustic_cost=0.07),
        nextstate=s2,
    ),
)

fst.add_arc(
    state=s1,
    arc=kaldifst.LatticeArc(
        ilabel=3,
        olabel=3,
        weight=kaldifst.LatticeWeight(graph_cost=0.1, acoustic_cost=0.3),
        nextstate=s3,
    ),
)

fst.add_arc(
    state=s1,
    arc=kaldifst.LatticeArc(
        ilabel=4,
        olabel=4,
        weight=kaldifst.LatticeWeight(graph_cost=0.15, acoustic_cost=0.05),
        nextstate=s3,
    ),
)

fst.add_arc(
    state=s2,
    arc=kaldifst.LatticeArc(
        ilabel=3,
        olabel=3,
        weight=kaldifst.LatticeWeight(graph_cost=0.15, acoustic_cost=0.15),
        nextstate=s3,
    ),
)

fst.add_arc(
    state=s2,
    arc=kaldifst.LatticeArc(
        ilabel=4,
        olabel=4,
        weight=kaldifst.LatticeWeight(graph_cost=0.05, acoustic_cost=0.15),
        nextstate=s3,
    ),
)

fst.set_final(state=s3, weight=kaldifst.LatticeWeight.one)


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)

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)

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="lattice.svg")

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

nbest_list = kaldifst.convert_nbest_to_vector(nbest_3)
for b in nbest_list:
    b.input_symbols = fst.input_symbols
    b.output_symbols = fst.output_symbols

nbest_list_0_dot = kaldifst.draw(nbest_list[0], acceptor=True, portrait=True)
nbest_list_0_source = graphviz.Source(nbest_list_0_dot)
nbest_list_0_source.render(outfile="lattice-3best-0.svg")

nbest_list_1_dot = kaldifst.draw(nbest_list[1], acceptor=True, portrait=True)
nbest_list_1_source = graphviz.Source(nbest_list_1_dot)
nbest_list_1_source.render(outfile="lattice-3best-1.svg")

nbest_list_2_dot = kaldifst.draw(nbest_list[2], acceptor=True, portrait=True)
nbest_list_2_source = graphviz.Source(nbest_list_2_dot)
nbest_list_2_source.render(outfile="lattice-3best-2.svg")

Fig. 33 Visualization of lattice-3best.svg

Fig. 34 Visualization of lattice-3best-0.svg

Fig. 35 Visualization of lattice-3best-1.svg

Fig. 36 Visualization of lattice-3best-2.svg

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).

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 22 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. 37 Visualization of transducer.svg (before determinization)

Fig. 38 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.

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 23 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. 39 Visualization of transducer.svg (before determinization)

Fig. 40 Visualization of transducer2.svg (after determinization)

divide

kaldifst.divide(*args, **kwargs)

Overloaded function.

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

draw

kaldifst.draw(*args, **kwargs)

Overloaded function.

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 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]
}

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 26 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 27 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]
}

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 28 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")

get_linear_symbol_sequence

kaldifst.get_linear_symbol_sequence(*args, **kwargs)

Overloaded function.

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 29 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

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 30 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.

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 31 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. 46 Visualization of before-invert.svg

Fig. 47 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 32 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

lattice_to_nbest

kaldifst.lattice_to_nbest(lat, acoustic_scale=1.0, lm_scale=1.0, n=1)

Work out N-best paths in lattices

It implements https://github.com/kaldi-asr/kaldi/blob/master/src/latbin/lattice-to-nbest.cc

Parameters

lat (Union[Lattice, StdVectorFst]) – The input lattice.
acoustic_scale (float) – Scaling factor for acoustic likelihoods.
lm_scale (float) – Scaling factor for language model scores.
n (int) – Number of distinct paths.

Return type

List[Union[Lattice, StdVectorFst]]

Returns

Return a list of linear FSTs.

Example for a StdVectorFst

Listing 33 lattice_to_nbest 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_list = kaldifst.lattice_to_nbest(a, n=3)
for b in nbest_list:
    b.input_symbols = a.input_symbols
    b.output_symbols = a.output_symbols

nbest_list_0_dot = kaldifst.draw(nbest_list[0], acceptor=True, portrait=True)
nbest_list_0_source = graphviz.Source(nbest_list_0_dot)
nbest_list_0_source.render(outfile="vector-fst-3best-0.svg")

nbest_list_1_dot = kaldifst.draw(nbest_list[1], acceptor=True, portrait=True)
nbest_list_1_source = graphviz.Source(nbest_list_1_dot)
nbest_list_1_source.render(outfile="vector-fst-3best-1.svg")

nbest_list_2_dot = kaldifst.draw(nbest_list[2], acceptor=True, portrait=True)
nbest_list_2_source = graphviz.Source(nbest_list_2_dot)
nbest_list_2_source.render(outfile="vector-fst-3best-2.svg")

Fig. 48 Visualization of vector-fst.svg

Fig. 49 Visualization of vector-fst-3best-0.svg

Fig. 50 Visualization of vector-fst-3best-1.svg

Fig. 51 Visualization of vector-fst-3best-2.svg

Example for a Lattice

Listing 34 lattice_to_nbest for a Lattice

#!/usr/bin/env python3

import graphviz

import kaldifst

fst = kaldifst.Lattice()
s0 = fst.add_state()
s1 = fst.add_state()
s2 = fst.add_state()
s3 = fst.add_state()

fst.start = s0
fst.add_arc(
    state=s0,
    arc=kaldifst.LatticeArc(
        ilabel=1,
        olabel=1,
        weight=kaldifst.LatticeWeight(graph_cost=0.02, acoustic_cost=0.08),
        nextstate=s1,
    ),
)

fst.add_arc(
    state=s0,
    arc=kaldifst.LatticeArc(
        ilabel=2,
        olabel=2,
        weight=kaldifst.LatticeWeight(graph_cost=0.03, acoustic_cost=0.07),
        nextstate=s2,
    ),
)

fst.add_arc(
    state=s1,
    arc=kaldifst.LatticeArc(
        ilabel=3,
        olabel=3,
        weight=kaldifst.LatticeWeight(graph_cost=0.1, acoustic_cost=0.3),
        nextstate=s3,
    ),
)

fst.add_arc(
    state=s1,
    arc=kaldifst.LatticeArc(
        ilabel=4,
        olabel=4,
        weight=kaldifst.LatticeWeight(graph_cost=0.15, acoustic_cost=0.05),
        nextstate=s3,
    ),
)

fst.add_arc(
    state=s2,
    arc=kaldifst.LatticeArc(
        ilabel=3,
        olabel=3,
        weight=kaldifst.LatticeWeight(graph_cost=0.15, acoustic_cost=0.15),
        nextstate=s3,
    ),
)

fst.add_arc(
    state=s2,
    arc=kaldifst.LatticeArc(
        ilabel=4,
        olabel=4,
        weight=kaldifst.LatticeWeight(graph_cost=0.05, acoustic_cost=0.15),
        nextstate=s3,
    ),
)

fst.set_final(state=s3, weight=kaldifst.LatticeWeight.one)


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)

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)

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="lattice.svg")

nbest_list = kaldifst.lattice_to_nbest(fst, n=3)
for b in nbest_list:
    b.input_symbols = fst.input_symbols
    b.output_symbols = fst.output_symbols

nbest_list_0_dot = kaldifst.draw(nbest_list[0], acceptor=True, portrait=True)
nbest_list_0_source = graphviz.Source(nbest_list_0_dot)
nbest_list_0_source.render(outfile="lattice-3best-0.svg")

nbest_list_1_dot = kaldifst.draw(nbest_list[1], acceptor=True, portrait=True)
nbest_list_1_source = graphviz.Source(nbest_list_1_dot)
nbest_list_1_source.render(outfile="lattice-3best-1.svg")

nbest_list_2_dot = kaldifst.draw(nbest_list[2], acceptor=True, portrait=True)
nbest_list_2_source = graphviz.Source(nbest_list_2_dot)
nbest_list_2_source.render(outfile="lattice-3best-2.svg")

Fig. 53 Visualization of lattice-3best-0.svg

Fig. 54 Visualization of lattice-3best-1.svg

Fig. 55 Visualization of lattice-3best-2.svg

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 35 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")

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.

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 36 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. 57 Visualization of acceptor.svg (before minimize)

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

Example 2: Minimize a transducer

Listing 37 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. 59 Visualization of transducer.svg (before minimize)

Fig. 60 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);

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 38 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. 61 Visualization of acceptor.svg (before minimize_encoded)

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

Example 2: Minimize encode a transducer

Listing 39 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. 63 Visualization of transducer.svg (before minimize_encoded)

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

plus

kaldifst.plus(*args, **kwargs)

Overloaded function.

plus(arg0: _kaldifst.TropicalWeight, arg1: _kaldifst.TropicalWeight) -> _kaldifst.TropicalWeight
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().

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 40 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. 65 Visualization of acceptor-before-reverse.svg

Fig. 66 Visualization of acceptor-after-reverse.svg using `require_superinitial=True`

Example 2 Revert an acceptor (require_superinitial=False)

Listing 41 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. 67 Visualization of acceptor-before-reverse-2.svg

Fig. 68 Visualization of acceptor-after-reverse-2.svg using `require_superinitial=False`

Example 3 Revert a transducer (require_superinitial=False)

Listing 42 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. 69 Visualization of transducer-before-reverse.svg

Fig. 70 Visualization of transducer-after-reverse.svg using `require_superinitial=True`

Example 4 Revert a transducer (require_superinitial=False)

Listing 43 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. 71 Visualization of transducer-before-reverse-2.svg

Fig. 72 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.

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 44 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. 73 Visualization of transducer.svg

Fig. 74 Visualization of transducer-after-rmepsilon.svg

scale_lattice

kaldifst.scale_lattice(scale: List[List[float]], in_out: _kaldifst.LatticeMutableFst) → None

Scales the pairs of weights in LatticeWeight by viewing the pair (a, b) as a 2-vector and pre-multiplying by the 2x2 matrix in “scale”. E.g. typically scale would equal

[ 1   0;
  0  acwt ]

if we want to scale the acoustics by acwt.

out_value1 = scale[0][0]*in_value1 + scale[0][1]*in_value2

out_value2 = scale[1][0]*in_value1 + scale[1][1]*in_value2

Parameters

scale – A list-of-list containing the weight
in_out – The lattice is changed in-place.

Returns

Return None.

Example 1: Use a diagonal scale [[0.1, 0], [0, 10]]

Listing 45 Scale a lattice.

#!/usr/bin/env python3

import graphviz

import kaldifst


fst = kaldifst.Lattice()
s0 = fst.add_state()
s1 = fst.add_state()
s2 = fst.add_state()
s3 = fst.add_state()

fst.start = s0
fst.add_arc(
    state=s0,
    arc=kaldifst.LatticeArc(
        ilabel=1,
        olabel=2,
        weight=kaldifst.LatticeWeight(graph_cost=0.1, acoustic_cost=0.2),
        nextstate=s1,
    ),
)

fst.add_arc(
    state=s0,
    arc=kaldifst.LatticeArc(
        ilabel=3,
        olabel=4,
        weight=kaldifst.LatticeWeight(graph_cost=0.3, acoustic_cost=0.4),
        nextstate=s2,
    ),
)

fst.add_arc(
    state=s1,
    arc=kaldifst.LatticeArc(
        ilabel=5,
        olabel=6,
        weight=kaldifst.LatticeWeight(graph_cost=0.5, acoustic_cost=0.6),
        nextstate=s3,
    ),
)

fst.add_arc(
    state=s2,
    arc=kaldifst.LatticeArc(
        ilabel=6,
        olabel=8,
        weight=kaldifst.LatticeWeight(graph_cost=0.7, acoustic_cost=0.8),
        nextstate=s3,
    ),
)

fst.set_final(
    state=s3, weight=kaldifst.LatticeWeight(graph_cost=0.2, acoustic_cost=0.5)
)

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

scale = kaldifst.lattice_scale(lmwt=0.1, acwt=10.0)

kaldifst.scale_lattice(scale, fst)

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

Fig. 76 After scale using `[[0.1, 0], [0, 10]]`.

Example 2: Use a non-diagonal scale [[0.1, 1], [0.5, 10]]

Listing 46 Scale a lattice.

#!/usr/bin/env python3

import graphviz

import kaldifst


fst = kaldifst.Lattice()
s0 = fst.add_state()
s1 = fst.add_state()
s2 = fst.add_state()
s3 = fst.add_state()

fst.start = s0
fst.add_arc(
    state=s0,
    arc=kaldifst.LatticeArc(
        ilabel=1,
        olabel=2,
        weight=kaldifst.LatticeWeight(graph_cost=0.1, acoustic_cost=0.2),
        nextstate=s1,
    ),
)

fst.add_arc(
    state=s0,
    arc=kaldifst.LatticeArc(
        ilabel=3,
        olabel=4,
        weight=kaldifst.LatticeWeight(graph_cost=0.3, acoustic_cost=0.4),
        nextstate=s2,
    ),
)

fst.add_arc(
    state=s1,
    arc=kaldifst.LatticeArc(
        ilabel=5,
        olabel=6,
        weight=kaldifst.LatticeWeight(graph_cost=0.5, acoustic_cost=0.6),
        nextstate=s3,
    ),
)

fst.add_arc(
    state=s2,
    arc=kaldifst.LatticeArc(
        ilabel=6,
        olabel=8,
        weight=kaldifst.LatticeWeight(graph_cost=0.7, acoustic_cost=0.8),
        nextstate=s3,
    ),
)

fst.set_final(
    state=s3, weight=kaldifst.LatticeWeight(graph_cost=0.2, acoustic_cost=0.5)
)

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

scale = [[0.1, 1], [0.5, 10]]

kaldifst.scale_lattice(scale, fst)

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

Fig. 78 After scale using `[[0.1, 1], [0.5, 10]]`.

shortest_path

kaldifst.shortest_path(*args, **kwargs)

Overloaded function.

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.

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 linear paths.

Example: shortest_path of a StdVectorFst

Listing 47 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. 79 Visualization of vector-fst.svg

Fig. 80 Visualization of vector-fst-1best.svg

Fig. 81 Visualization of vector-fst-2best.svg

Fig. 82 Visualization of vector-fst-3best.svg

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

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

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.

Parameters

n – Size of n-best.
unique – Return only distinct strings. (NB: must be acceptor; epsilons treated as regular symbols)

Returns

Return a Lattice containing n linear paths.

Example: shortest_path of a Lattice

Listing 48 ShortestPath for a Lattice

#!/usr/bin/env python3

import graphviz

import kaldifst

fst = kaldifst.Lattice()
s0 = fst.add_state()
s1 = fst.add_state()
s2 = fst.add_state()
s3 = fst.add_state()

fst.start = s0
fst.add_arc(
    state=s0,
    arc=kaldifst.LatticeArc(
        ilabel=1,
        olabel=1,
        weight=kaldifst.LatticeWeight(graph_cost=0.02, acoustic_cost=0.08),
        nextstate=s1,
    ),
)

fst.add_arc(
    state=s0,
    arc=kaldifst.LatticeArc(
        ilabel=2,
        olabel=2,
        weight=kaldifst.LatticeWeight(graph_cost=0.03, acoustic_cost=0.07),
        nextstate=s2,
    ),
)

fst.add_arc(
    state=s1,
    arc=kaldifst.LatticeArc(
        ilabel=3,
        olabel=3,
        weight=kaldifst.LatticeWeight(graph_cost=0.1, acoustic_cost=0.3),
        nextstate=s3,
    ),
)

fst.add_arc(
    state=s1,
    arc=kaldifst.LatticeArc(
        ilabel=4,
        olabel=4,
        weight=kaldifst.LatticeWeight(graph_cost=0.15, acoustic_cost=0.05),
        nextstate=s3,
    ),
)

fst.add_arc(
    state=s2,
    arc=kaldifst.LatticeArc(
        ilabel=3,
        olabel=3,
        weight=kaldifst.LatticeWeight(graph_cost=0.15, acoustic_cost=0.15),
        nextstate=s3,
    ),
)

fst.add_arc(
    state=s2,
    arc=kaldifst.LatticeArc(
        ilabel=4,
        olabel=4,
        weight=kaldifst.LatticeWeight(graph_cost=0.05, acoustic_cost=0.15),
        nextstate=s3,
    ),
)

fst.set_final(state=s3, weight=kaldifst.LatticeWeight.one)


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)

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)

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="lattice.svg")

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

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

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

Fig. 84 Visualization of lattice-1best.svg

Fig. 85 Visualization of lattice-2best.svg

Fig. 86 Visualization of lattice-3best.svg

times

kaldifst.times(*args, **kwargs)

Overloaded function.

times(arg0: _kaldifst.TropicalWeight, arg1: _kaldifst.TropicalWeight) -> _kaldifst.TropicalWeight
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

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.

__init__(self: _kaldifst.LatticeArc) -> None
__init__(self: _kaldifst.LatticeArc, ilabel: int, olabel: int, weight: _kaldifst.LatticeWeight, nextstate: int) -> None
__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.

__init__(self: _kaldifst.StdArc) -> None
__init__(self: _kaldifst.StdArc, ilabel: int, olabel: int, weight: _kaldifst.TropicalWeight, nextstate: int) -> None
__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

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

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

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.

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).

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.

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.

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

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

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

kaldifst

add_self_loops

arcsort

compile

compose

compose_context

connect

convert_nbest_to_vector

determinize

determinize_star

divide

draw

equal_align

get_linear_symbol_sequence

info

invert

lattice_scale

lattice_to_nbest

make_linear_acceptor

minimize

minimize_encoded

plus

reverse

rmepsilon

scale_lattice

shortest_path

times

ArcIterator

done

flags

position

value

FloatWeight

value

Lattice

copy

input_symbols

is_ilabel_sorted

is_olabel_sorted

num_states

output_symbols

start

type

LatticeArc

__init__

ilabel

nextstate

olabel

weight

LatticeWeight

value1

value2

RandomAccessVectorFstReader

is_open

SequentialVectorFstReader

done

is_open

key

value

StateIterator

done

value

StdArc

__init__

ilabel

nextstate

olabel

weight

StdConstFst

copy

input_symbols

is_ilabel_sorted

is_olabel_sorted

num_states

output_symbols

start

type

StdFst

copy

input_symbols

init

init