Python 您甚至如何提供（openFST制作的）FST输入？输出到哪里去了？

在开始之前，请注意我使用的是linux shell（通过Python中的

使用subprocess.call（）

），我使用的是openFST

我一直在筛选有关openFST的文档和问题，但我似乎找不到这个问题的答案：如何为openFST定义、编译和组合的FST提供输入？输出到哪里去了？我只是执行“fstproject”吗？如果是这样的话，我该如何，比如说，给它一个字符串进行转换，并在达到最终状态时打印各种转换

---

如果这个问题看起来很明显，我道歉。到目前为止，我还不太熟悉openFST。

一种方法是创建执行转换的机器。 一个非常简单的例子是将字符串大写

M.wfst

0 0 a A
0 0 b B
0 0 c C
0

附带的符号文件包含字母表中每个符号的一行。注0为空（ε）转换保留，在许多操作中具有特殊意义

M.syms

<epsilon> 0
a 1
b 2
c 3
A 4
B 5
C 6

对于输入字符串“abc”创建线性链自动机，这是一个从左到右的链，每个字符有一个弧。这是一个接受程序，因此我们只需要为 输入符号

I.wfst

0 1 a
1 2 b
2 3 c
3  

作为接受者编译

fstcompile --isymbols=M.syms --acceptor I.wfst > I.ofst

然后组装机器并打印

fstcompose I.ofst M.ofst | fstprint --isymbols=M.syms --osymbols=M.syms 

这将给出输出

0   1   a   A
1   2   b   B
2   3   c   C
3

fstcompose的输出是输入字符串的所有转换的晶格。（在本例中，只有一个）。如果M.ofst更复杂，那么fstshortestpath可以使用标志--unique-nshortest=n来提取n个字符串。这个输出又是一个转换器，你可以丢弃FSTPress输出，或者使用C++代码和OpenFST库来运行深度优先搜索来提取字符串。 插入fstproject--project_output将把输出转换为只包含输出标签的接受器

fstcompose I.ofst M.ofst | fstproject --project_output |  fstprint --isymbols=M.syms --osymbols=M.syms 

给出以下内容

0  1  A  A
1  2  B  B
2  3  C  C
3

这是一个接受程序，因为输入和输出标签相同，--acceptor选项可用于生成更简洁的输出

 fstcompose I.ofst M.ofst | fstproject --project_output |  fstprint --isymbols=M.syms --acceptor

---

保罗·迪克森的例子很好。由于OP使用Python，我想我应该添加一个关于如何使用“运行”转换器的快速示例。遗憾的是，您无法使用开放式FST创建“线性链自动机”，但自动化很简单，如下所示：

def linear_fst(elements, automata_op, keep_isymbols=True, **kwargs):
    """Produce a linear automata."""
    compiler = fst.Compiler(isymbols=automata_op.input_symbols().copy(), 
                            acceptor=keep_isymbols,
                            keep_isymbols=keep_isymbols, 
                            **kwargs)

    for i, el in enumerate(elements):
        print >> compiler, "{} {} {}".format(i, i+1, el)
    print >> compiler, str(i+1)

    return compiler.compile()

def apply_fst(elements, automata_op, is_project=True, **kwargs):
    """Compose a linear automata generated from `elements` with `automata_op`.

    Args:
        elements (list): ordered list of edge symbols for a linear automata.
        automata_op (Fst): automata that will be applied.
        is_project (bool, optional): whether to keep only the output labels.
        kwargs:
            Additional arguments to the compiler of the linear automata .
    """
    linear_automata = linear_fst(elements, automata_op, **kwargs)
    out = fst.compose(linear_automata, automata_op)
    if is_project:
        out.project(project_output=True)
    return out

让我们定义一个大写字母“a”的简单传感器：

输出：

---

要了解如何使用它作为接受者，请查看我更新Yann Dubois对python3的回答：

将pywrapfst导入为fst
打印（“”）
f\u ST:fst.SymbolTable
def linear_fst（元素、自动机运算、保持符号=True、**kwargs）：
“”“生成线性自动机。”“”
编译器=fst.compiler(
isymbols=f#ST，#应该有办法从automata#op获取此信息
接受者=保留符号，
keep_isymbols=keep_isymbols，
**夸尔斯
)
对于i，枚举中的el（元素）：
打印（“{}{}”。格式（i，i+1，el），end=“”，file=compiler）
打印（str（i+1），end=”“，file=compiler）
lf=compiler.compile（）
返回lf
def apply_fst（元素、自动机运算、打印=True、is_项目=False、**kwargs）：
“”“将由`elements`生成的线性自动机与`automata\u op`组合起来。”。
Args：
元素（列表）：线性自动机的边符号的有序列表。
自动机（Fst）：将应用的自动机。
print_la（bool，可选）：将线性自动机打印为文本表示
is_项目（str，可选）：是否仅保留“输入”或“输出”标签。
kwargs：线性自动机编译器的附加参数。
"""
线性自动机=线性自动机（元素，自动机运算，**kwargs）
如果要打印：
打印（“线性自动机：\n”，线性自动机）
out=fst.compose（线性自动机，自动机op）
如果是联合国项目：
输出项目（“输出”）
返回
f_ST=fst.SymbolTable（）
添加符号（“，0）
f_街添加_符号（“A”，1）
f_街添加_符号（“a”，2）
f街添加符号（“b”，3）
编译器=fst.compiler(
isymbols=f_ST，osymbols=f_ST，keep_isymbols=True，keep_osymbols=True
)
打印（“0 a”，end=”“，file=编译器）
打印（“0 b”，end=”“，file=编译器）
打印（“0”，end=”“，file=编译器）
caps_A=compiler.compile（）
打印（“大写传感器带”，大写字母A.num\u states（），“states:\n”，大写字母A）
caps_I=应用（列表（“abab”），caps_A）
打印（“输出：\n”，大写字母I）

这张照片是：

Uppercase Transducer with 1 states:
 0  0   a   A
0   0   b   b
0

Linear Automata:
 0  1   a   2
1   2   b   3
2   3   a   2
3   4   b   3
4

Output:
 0  1   a   A
1   2   b   b
2   3   a   A
3   4   b   b
4

---

这是一个很好的答案，示例非常有用！非常感谢。我觉得openfst没有提供一种创建“线性链自动机”的方法有点令人难以置信。

f_ST = fst.SymbolTable()
f_ST.add_symbol("<eps>", 0)
f_ST.add_symbol("A", 1)
f_ST.add_symbol("a", 2)
f_ST.add_symbol("b", 3)
compiler = fst.Compiler(isymbols=f_ST, osymbols=f_ST, keep_isymbols=True, keep_osymbols=True)

print >> compiler, "0 0 a A"
print >> compiler, "0 0 b b"
print >> compiler, "0"
caps_A = compiler.compile()
caps_A

apply_fst(list("abab"), caps_A)

Uppercase Transducer with 1 states:
 0  0   a   A
0   0   b   b
0

Linear Automata:
 0  1   a   2
1   2   b   3
2   3   a   2
3   4   b   3
4

Output:
 0  1   a   A
1   2   b   b
2   3   a   A
3   4   b   b
4