用于次正则和后续语法归纳的包

项目描述

自述文件上次更新时间：2020 年 3 月 23 日

用于次正则和后续语法归纳的SigmaPie

安装

pip install sigmapie

用法

import sigmapie
# learning UTP pattern with an SP grammar
language = sigmapie.SP(polar="n")
language.k = 3
language.data = ["HHLLL", "LLHHH", "LHHHLL", "LLL", "HHH"]
language.alphabet = ["H", "L"]
language.learn()
language.grammar # [('H', 'L', 'H')]
language.scan("HHLLLL") # True
language.scan("HLLH") # False
language.generate_sample(n = 3) # ['LLHH', 'HL', 'HHHL']

音韵学中的次常规语言和映射

从理论语言学和形式语言理论的角度来看，该工具包适用于任何正在或将要使用次正则语法的人。

为什么理论语言学家可能对形式语言理论感兴趣？
形式语言理论解释了如何将潜在的无限字符串集或形式语言推广到编码所需模式的语法以及这些语法具有哪些属性。它还允许人们比较关于参数的不同语法，例如表达性。

Chomsky 层次结构将形式语言的主要类别与它们的表达能力保持一致（Chomsky 1959）。

正则文法与有限状态设备或正则表达式一样强大：它们只能“计数”到某个阈值（无a^n b^n模式）；
上下文无关语法可以访问潜在的无限堆栈，从而允许它们重现涉及中心嵌入的模式；
温和的上下文敏感语法足够强大，可以处理跨序列依赖，例如某些类型的复制；
上下文相关文法可以处理非线性模式，例如a^2^nfor n > 0;
递归可枚举文法与任何理论上可能的计算机一样强大，并且可以生成诸如a^n, 其中n是质数的语言。

音韵学和形态学都经常显示常规语言的属性。

音系不需要中心嵌入的力量，这是上下文无关语言的一个属性。例如，考虑一个和声，其中第一个元音与最后一个元音一致，第二个元音与最后一个元音一致，等等。

GOOD: "arugula", "tropicalization", "electrotelethermometer", etc.
BAD:  any other word violating the rule.

虽然这是一种理论上可能的模式，但这种类型的和声在自然语言中是未经证实的。

形态学也避免了中心嵌入。在Aksënova 等人中。（2016 年）我们展示了在俄语中迭代具有“之后”含义的前缀是可能的。在 Ilocano 中，相同的语义通过一个外接符来表达，它的迭代是被禁止的。

RUSSIAN: "zavtra" (tomorrow), "posle-zavtra" (the day after tomorrow), 
         "posle-posle-zavtra" (the day after the day after tomorrow), ...
ILOCANO: "bigat" (morning), "ka-bigat-an" (the next morning),
         <*>"ka-ka-bigat-an-an" (the morning after the next one).

此外，模式的类型学审查表明，音韵学和形态学不需要常规语言的全部力量。作为未经证实的模式的一个例子，Heinz (2011)提供了一种语言，其中一个单词必须有偶数个元音才能形成良好的格式。

正则语言可以细分为另一个嵌套的语言层次结构，其表达能力会降低：亚正则层次结构。次正则语言的一些最重要特征之一是它们仅可从正数据中学习：更强大的类也需要负输入。

但是，当存在映射时，即输入形式与其输出对应物的对应关系时，可以使用子正则映射。实际上，在语言学中，将底层表示 (UR) 映射到表面形式 (SF) 是一项常见的任务。编码映射规则的方法之一是使用转换器。一类不规则或次规则换能器是后续换能器。它们确定性地逐一读取输入字符串，并输出输出字符串的相应部分。

SigmaPie工具包目前包含以下子常规语言和语法类的功能：

严格分段（SP）；
严格本地化（SL）；
基于层的严格本地（TSL）；
基于多层的严格本地（MTSL）。

此外，它实现了 OSTIA 算法，该算法根据Oncina、Garcia 和 Vidal (1993)和Colin de la Higuera (2014)学习后续映射。

工具包的功能

学习者从字符串集中提取语法。
扫描器根据给定的语法评估字符串。
样本生成器为给定的语法生成字符串集。
FSM 构造函数将次正则文法转换为有限状态机。
极性转换器将否定语法转换为肯定语法，反之亦然。

严格分段语言

负严格分段 (SP)文法禁止符号序列在彼此之间任意距离处出现。每个 SP 文法都与k定义该文法可以禁止的最长序列大小的值相关联。或者，如果语法是肯定的，它会列出该语言的格式良好的单词中允许的所有子序列。

k = 2
POLARITY: negative
GRAMMAR:  ab, ba
LANGUAGE: accaacc, cbccc, cccacaaaa, ...
          <*>accacba, <*>bcccacbb, <*>bccccccca, ...

在音韵学中，SP 模式的一个例子是Jardine (2015, 2016)中讨论的音调平台。例如，在卢干达语（班图语）中，低音（L）不能插入两个高音（H）之间：在这种配置中，L 变为 H。韵律域不能有超过一段 H 音。

Luganda 动词和名词组合（Hyman 和 Katamba (2010) ， Jardine (2016)引用）

/tw-áa-mú-láb-a, walúsimbi/ ---> tw-áá-mu-lab-a, walúsimbi
'我们看到了他，Walusimbi'
HHLLL, LHLL
/tw-áa-láb-wa walúsimbi/ ---> tw-áá-láb-wá wálúsimbi
'我们被 Walusimbi 看到了'
HHHHHHLL
/tw-áa-láb-a byaa=walúsimbi/ ---> tw-áá-láb-á byáá-wálúsimbi
'我们看到了 Walusimbi 的那些'
HHHHHHHHLL

这种模式可以用 SP 语法来描述*HLH。

学习音调平稳模式

让我们说它luganda代表了色调平稳 (TP) 模式的“玩具”示例。

luganda = ["LLLL", "HHLLL", "LHHHLL", "LLLLHHHH"]

我们的目标是学习 TP 背后的 SP 泛化。

负和正 SP 语法被实现为 class SP()。下一个代码单元初始化了一个正 SP 语法tp_pattern。

tp_pattern = SP()

SP文法的属性

polar("p" or "n") 是语法的极性，默认是"p"；
alphabet(list) 是语法使用的符号集；
grammar（元组列表）是语言允许或禁止子结构的列表；
k(int) 为语法局部窗口的大小，默认为2；
data(list of string) 是学习样本；
fsm（FSM 对象）是对应于文法的有限状态设备。

第一步是定义训练样本和字母表。

tp_pattern.data = luganda
tp_pattern.alphabet = ["H", "L"]

默认情况下，语法的局部性窗口为 2。

print("Locality of the SP grammar:", tp_pattern.k)

SP属性可以直接访问。例如，让我们将窗口的位置从 2 更改为 3：

tp_pattern 。k  =  3 
print("Locality of the SP grammar:", tp_pattern.k)

为 SP 语法定义的方法

check_polarity()并switch_polarity()显示和改变语法的极性；
learn()从训练样本中提取禁止或允许的子序列；
scan(string)告诉给定的字符串相对于学习的语法是否格式正确；
extract_alphabet()根据数据或语法属性收集字母；
generate_sample(n, repeat)根据给定的语法生成 $n$ 个字符串；默认情况下，repeat设置为False，生成的字符串不允许重复，但该参数可以设置为True；
fsmize()按照Heinz 和 Rogers (2013)中概述的步骤创建相应的 FSM 系列；
subsequences(string)返回k给定字符串的所有分段子序列；
generate_all_ngrams()根据提供的字母表生成所有可能的长度为 $k$ 的字符串。

检查和改变语法的极性

默认情况下，语法是肯定的。可以通过运行以下check_polarity方法检查极性：

print("Polarity of the grammar:", tp_pattern.check_polarity())

如果需要改变极性，可以使用该switch_polarity方法来完成。如果提供或已经提取了一种语法，它将自动切换到相反的语法。

tp_pattern 。switch_polarity () 
print("Polarity of the grammar:", tp_pattern.check_polarity())

学习SP语法

方法learn根据语法的极性和位置窗口从学习样本中提取允许或禁止的子序列。

tp_pattern.learn()
print("Extracted grammar:", tp_pattern.grammar)

确实，它学会了 TP 模式！

$n$-grams 表示为字符串的元组，因为在这种情况下，字母表的元素不限于字符。

扫描字符串并判断它们是否是语言的一部分

scan将字符串作为输入并根据给定字符串相对于编码语法的格式正确返回 True 或 False。

tp = ["HHHLLL", "L", "HHL", "LLHLLL"]
no_tp = ["LLLLHLLLLH", "HLLLLLLH", "LLLHLLLHLLLHL"]

print("Tonal plateauing:")
for string in tp:
    print("String", string, "is in L(G):", tp_pattern.scan(string))
    
print("\nNo tonal plateauing:")
for string in no_tp:
    print("String", string, "is in L(G):", tp_pattern.scan(string))

生成数据样本

基于学习的语法，可以生成所需大小的数据样本。

sample = tp_pattern.generate_sample(n = 10)
print("Sample:", sample)

提取子序列

最后，该工具包还可用于通过将输入词提供给subsequences方法来从输入词中提取子序列。

tp_pattern.k = 3
print("k = 3:", tp_pattern.subsequences("regular"), "\n")
tp_pattern.k = 5
print("k = 5:", tp_pattern.subsequences("regular"))

虽然 SP 语言捕获多个长距离过程，例如音调平稳或某些和声，但它们无法编码阻塞效应或纯粹的本地过程。

严格的当地语言

负严格局部 (SL)文法禁止出现由多达k符号组成的连续子串。的值k定义了不能出现在格式良好的语言字符串中的最长子字符串。正 SL 语法定义了可以在语言中出现的子字符串。

重要的是，为了定义第一个和最后一个元素，SL 语言使用分隔符（“>”和“<”）来指示字符串的开头和结尾。

k = 2
POLARITY: positive
GRAMMAR:  >a, ab, ba, b<
LANGUAGE: ab, abab, abababab, ...
          <*>babab, <*>abaab, <*>bababba, ...

在音韵学中，变化经常涉及相邻的片段，因此局部性的概念非常重要。关于音韵学中局部过程的讨论可以在(Chandlee 2014)中找到。

俄语词尾除音

在俄语中，一个单词的最后一个阻塞音不能发声。

“lug”[luK]草地--->草地的“lug-a”[luGa ]
“luk”[luK]洋葱--->洋葱的“luk-a”[luKa ]
"porog" [paroK]门阶---> "porog-a" [paroGa]门阶
"porok"[paroK]副--->副的"porok-a"[paroKa ]

学习词尾除音

假设以下玩具数据集定义了以下映射：

“a”代表元音；
“b”代表浊音；
“p”代表任何其他辅音。

russian = ["", "ababa", "babbap", "pappa", "pabpaapba" "aap"]

在这个术语中，俄语词尾的除音泛化将是“在词尾没有“b””。

然后可以使用 SL 语法来描述这种模式*b<。

让我们初始化一个 SL 对象。

wf_devoicing = SL()
wf_devoicing.data = russian

SL 语法的属性

polar("p" or "n") 是语法的极性，默认是"p"；
alphabet(list) 是语法使用的符号集；
grammar（元组列表）是语言允许或禁止子结构的列表；
k(int) 为语法局部窗口的大小，默认为2；
data(list of string) 是学习样本；
edges（两个字符的列表）是语法使用的分隔符，默认值为“>”和“<”；
fsm（FSM 对象）是对应于文法的有限状态设备。

为 SL 语法定义的方法

check_polarity()并switch_polarity()显示和改变语法的极性；
learn()从训练样本中提取禁止或允许的子字符串；
scan(string)告诉给定的字符串相对于学习的语法是否格式正确；
extract_alphabet()根据数据或语法收集字母；
generate_sample(n, repeat)根据给定的语法生成 $n$ 个字符串；默认情况下，repeat设置为False，生成的字符串不允许重复，但该参数可以设置为True；
fsmize()创建相应的FSA；
clean_grammar()从语法中删除无用的 k-gram。

提取字母和学习SL语法

和以前一样，learn()从数据中提取依赖关系。它只是从数据中提取指定大小的 k-gram，默认值为k2。

wf_devoicing.learn()
print("The grammar is", wf_devoicing.grammar)

为了自动从数据中提取字母表，可以运行extract_alphabet().

print("The original value of the alphabet is", wf_devoicing.alphabet)
wf_devoicing.extract_alphabet()
print("The modified value of the alphabet is", wf_devoicing.alphabet)

改变语法的极性

上面输出的语法是肯定的。如果我们想使用限制而不是允许的子字符串来捕获模式，我们可以switch_polarity()使用以下语法：

wf_devoicing.switch_polarity()
print("The grammar is", wf_devoicing.grammar)

扫描字符串

和以前一样，scan(string)方法返回 True 或 False 取决于给定字符串相对于学习语法的格式良好。

wfd = ["apapap", "papa", "abba"]
no_wfd = ["apab", "apapapb"]

print("Word-final devoicing:")
for string in wfd:
    print("String", string, "is in L(G):", wf_devoicing.scan(string))
    
print("\nNo word-final devoicing:")
for string in no_wfd:
    print("String", string, "is in L(G):", wf_devoicing.scan(string))

生成数据样本

如果语法为非空，则可以像之前一样生成数据样本：generate_sample(n, repeat)，其中n是需要生成的样本数，repeat是允许或禁止在生成的数据中重复相同字符串的标志.

sample = wf_devoicing.generate_sample(5, repeat = False)
print(sample)

清理语法

潜在地，用户提供的语法可能包含“无用的”k-gram。例如，考虑以下语法：

sl = SL()
sl.grammar = [(">", "a"), ("b", "a"), ("a", "b"), ("b", "<"),
              (">", "g"), ("f", "<"), ("t", "t")]
sl.alphabet = ["a", "b", "g", "f", "t"]

该文法包含 3 个无用的二元组：

(">", "g")永远不能使用，因为“g”后面不能有任何东西；
("f", "<")没用，因为没有办法开始一个会导致“f”的字符串；
("t", "t")有上面列出的两个问题。

方法clean_grammar()通过构造相应的 FSM 并修剪其不可访问状态来删除此类 $n$-gram。

print("Old grammar:", sl.grammar)
sl.clean_grammar()
print("Clean grammar:", sl.grammar)

尽管 SP 和 SL 语言可以捕捉很大一部分的音韵结构良好的条件，但仍有许多需要增加复杂性的模式示例。例如，使用 SP 语法无法捕获具有阻塞效果的和谐，因为它们会“错过”阻塞器，并且无法通过 SL 语法进行编码，因为它们不能用于长距离处理。

基于层的严格本地语言

基于层的严格本地 (TSL)语法的操作与严格本地语法一样，但它们具有完全忽略特定符号集的能力。未被忽略的符号集称为层符号，而对字符串的良好格式无关紧要的是非层符号（Heinz et al. 2011）。

假设我们有以下几组等级和非等级符号。

tier = [l, r]
non_tier = [c, d]

当 TSL 语法评估字符串时，非层符号将被忽略，因此字母表tier和non_tier定义以下映射：

l cc r dc l cddc rl c ---> lrlrl
rl dcd r cc l dcd r d l ---> rlrlrl
cdcddcdcdcdc -> e

右侧的字符串称为原始字符串的层图像，因为它们排除了所有非层符号。然后可以将 TSL 文法定义为在层上操作的 SL 文法。

继续上面的例子，除非“r”介入，否则我们禁止“l”跟随“l”，除非“l”介入，否则禁止“r”跟随“r”（它会产生一个玩具拉丁异化模式）。上，带有限制的tier否定 TSL 文法表达了这条规则。*ll*rr

直观地说，TSL 语法通过仅评估字符串的层图像来使非本地依赖关系成为本地的。

拉丁液体异化

在拉丁语中，液体倾向于交替：如果词干的最后液体是“l”，则形容词词缀被实现为“aris”。反之亦然，如果最终的液体是“r”，则词缀的选择是“alis”。考虑下面的例子。

mi l ita r是 ~ <*> mil ita l是“军事”
f l o r a l是 ~ <*>f l o r a r是“花香”
p l u r a l是 ~ <*>p l u r a r是“复数”

这种模式不是 SP，因为 SP 语法不能表现出阻塞效应，也不是 SL，因为它的长距离性质。

lat_dissim = TSL()

TSL 语法的属性

polar("p" or "n") 是语法的极性，默认值为"p"；
alphabet(list) 是语法使用的符号集；
grammar（元组列表）是该语言允许或禁止的子字符串列表；
k(int) 为语法局部性窗口的大小，默认为$2$；
data(list of string) 是学习样本；
edges（两个字符的列表）是语法使用的分隔符，默认值为“>”和“<”；
fsm（FSM对象）是对应于文法的有限状态设备；
tier(list) 是层符号的列表。

为 TSL 语法定义的方法

check_polarity()并switch_polarity()显示和改变语法的极性；
learn()检测层符号并学习层语法；
tier_image(string)返回给定字符串的层图像；
scan(string)告诉给定的字符串相对于学习的语法是否格式正确；
extract_alphabet()根据数据或语法收集字母；
generate_sample(n, repeat)根据给定的语法生成 $n$ 个字符串；默认情况下，repeat设置为False，生成的字符串不允许重复，但该参数可以设置为True；
fsmize()创建相应的FSA；
clean_grammar()从语法中删除无用的 k-gram。

学习液体异化

假设玩具拉丁异化数据集，我们将每个非液体掩蔽为“c”。

lat_dissim.data = ["ccc", "lccrcccclcr", "lrl", "rcclc"]

提取字母

我们不需要明确提供字母表。相反，它可以使用该extract_alphabet()方法从数据中提取。

lat_dissim.extract_alphabet()
print("Alphabet:", lat_dissim.alphabet)

学习层次和语法

提取字母表并提供训练样本后，我们可以学习依赖关系。

lat_dissim.learn()
print('Tier:   ', lat_dissim.tier)
print('Grammar:', lat_dissim.grammar)

切换极性

默认情况下，语法是肯定的，但是当表示为限制时，这种模式会更加清晰。switch_polarity()我们可以使用该方法将肯定语法转换为否定语法。

print("Initial polarity of the grammar:", lat_dissim.check_polarity(), "\n")
lat_dissim.switch_polarity()
print("New polarity of the grammar:", lat_dissim.check_polarity())
print("New grammar:", lat_dissim.grammar)

学习压力高潮

我们也可以直接学习否定语法。例如，让我们学习这样的模式：

aaabaaaa, baaaa, aaaaaba, aaaaaab, ...
<*>aababaaa, <*>baaaababb, <*>aaaa, ...

简而言之，所需的模式是字符串中必须存在单个“b”。把它翻译成与语言学相关的模式会给我们强调高潮。

stress = TSL(polar="n")
stress.data = ["aaabaaaa", "baaaa", "aaaaaba", "aaaaaab"]
stress.extract_alphabet()
stress.learn()

print("Tier:    ", stress.tier)
print("Grammar: ", stress.grammar)

习得的否定 TSL 语法禁止空层（重音必须出现在单词中）并禁止存在多个重音的层。

生成样本

数据样本生成也可用于 TSL 语言类。可以通过更改参数来允许或禁止数据集中相同项目的重复repeat。

print(stress.generate_sample(n=10, repeat=True))

print(stress.generate_sample(n=10, repeat=False))

实现的 k-TSL 语言学习算法由McMullin 和 Jardine (2017)设计，该算法基于Jardine 和 Heinz (2016)。

然而，有些语音过程需要比 TSL 更多的能量。一些语言不仅仅是单一的长距离同化：例如，单独的元音和辅音和声。在这种情况下，一层是不够的：将元音和辅音放在一个层上将在元音和辅音之间创建所需的位置。对于这种情况，基于多层的严格本地语言的子常规类特别有用。

基于多层的严格本地语言

类型学文献中有许多例子表明，语音模式的复杂性超出了 TSL 语言的能力。该示例可以是多个长距离依赖关系影响不同元素集的任何模式，有关这些模式的示例和讨论，请参见McMullin (2016)和Aksënova 和 Deshmukh (2018)。

两种特征传播，只能屏蔽其中一种

第一个例子来自 Imdlawn Tashlhiyt (Hansson 2010)。咝咝声在发声和前音方面逐渐一致。

s -a s: twa CAUS-解决
S -fia S r CAUS-be.full.of.straw
z -bru z：一个CAUS 崩溃
Z -m: Z dawl CAUS-stumble

然而，虽然发声和声可以被清音障碍物阻挡，但它们对于先验协议是透明的。

s -m X a z aj CAUS-loathe.each.other
S - q u Z: i CAUS-be.dislocated

为了捕捉发声和声，需要投射阻塞器，但是，将这些阻塞器放在层上会使嘶嘶声不再相邻，因此会导致前向和声问题。

元音和声和辅音和声

在 Bukusu 中，元音在高度上是一致的，如果在单词更远的地方紧跟“r”，则液体“l”同化为“r” （Odden 1994）。

r ee b- e r - ask-APPL
l i m- i l -培养-APPL
r u m- i r -发送-APPL

包含元音和液体的层不会捕捉到这张图片。中间的元音会使液体在层上非局部传播，而中间的液体会导致元音在层上可能彼此远离。

基于多层的严格局部语法是多个 TSL 语法的结合：它们由多个层组成，并且为这些层中的每一层定义了限制。例如，考虑以下玩具示例。

Good strings: aaabbabba, oppopooo, aapapapp, obooboboboobbb, ...
Bad strings:  <*>aabaoob, <*>paabab, <*>obabooo, ...
Generalization: if a string contains "a", it cannot contain "o", and vice versa;
                if a string contains "p", it cannot contain "b", and vice versa.

编码这种模式需要两层：一层元音（“o”和“a”）和一层辅音（“p”和“b”）。这种限制可以通过以下 MTSL 语法来表达，其中包含元音“a”和“o”的层施加了限制*ao和*oa，而包含p和b排除*pb的辅音层*bp。

学习“独立”的元音和辅音和声

data = ['aabbaabb', 'abab', 'aabbab', 'abaabb', 'aabaab', 'abbabb', 'ooppoopp',
        'opop', 'ooppop', 'opoopp', 'oopoop', 'oppopp', 'aappaapp', 'apap',
        'aappap', 'apaapp', 'aapaap', 'appapp', 'oobboobb', 'obob', 'oobbob',
        'oboobb', 'ooboob', 'obbobb', 'aabb', 'ab', 'aab', 'abb', 'oopp', 'op',
        'oop', 'opp', 'oobb', 'ob', 'oob', 'obb', 'aapp', 'ap', 'aap', 'app',
        'aaa', 'ooo', 'bbb', 'ppp', 'a', 'o', 'b', 'p', '']

第一步是初始化 MTSL 对象。

harmony = MTSL()

MTSL 语法的属性

polar("p" or "n") 是语法的极性，其中 "p" 是默认值；
alphabet(list) 是语法使用的符号集；
grammar(dictionary) 是一个字典，其中键（元组）是层字母表，值（列表）是对这些层施加的限制；
k(int) 为语法局部窗口的大小，默认为2；
data(list of string) 是学习样本；
edges（两个字符的列表）是语法使用的分隔符，默认值为“>”和“<”。

为 MTSL 语法定义的方法

check_polarity()并switch_polarity()显示和改变语法的极性；
learn()检测层符号并学习层语法；
scan(string)告诉给定的字符串相对于学习的语法是否格式正确；
extract_alphabet()根据数据和语法收集字母表。

提取字母和学习语法

现在我们可以初始化MTSL 类的data和属性，并应用该方法来学习相应的层和语法。alphabetlearn

harmony.data = data
harmony.extract_alphabet()
harmony.learn()

属性的值grammar用以下方式表示：

G = {
        tier_1 (tuple): tier_1_restrictions (list),
        tier_2 (tuple): tier_2_restrictions (list),
            ...
        tier_n (tuple): tier_n_restrictions (list)
    }

for i in harmony.grammar:
    print("Tier:", i)
    print("Restrictions;", harmony.grammar[i], "\n")

切换极性

默认学习的语法是肯定的并且非常冗长，并且可以通过应用该switch_polarity方法轻松转换为否定语法。

print ( "旧极性：" ， 和谐。check_polarity () )和谐。switch_polarity () print ( "新极性：" , Harmony . check_polarity (), " \n " )

  

for i in harmony.grammar:
    print("Tier:", i)
    print("Restrictions;", harmony.grammar[i], "\n")

2-MTSL 语言的学习算法由McMullin 等人设计。（2019）。

扫描字符串

和以前一样，该scan方法会判断给定的字符串相对于学习的语法是否格式正确。

good = ["apapappa", "appap", "popo", "bbbooo"]
bad = ["aoap", "popppa", "pabp", "popoa"]

for s in good:
    print("String", s, "is in L(G):", harmony.scan(s))
print()
for s in bad:
    print("String", s, "is in L(G):", harmony.scan(s))

MTSL相关研究的现状

我们目前正在进行理论工作，将 MTSL 语言的学习算法从捕获 2-local 依赖项扩展到k. 因此，该工具包的该模块将随着该语言课程的理论工作的进展而更新。

使用 OSTIA 学习映射

现在，让我们捕捉特征变化过程，而不是定义良构条件。假设传播从左到右移动，我们就可以掩盖单词中所有非开头提到的元音和辅音。

[("baABB", "baabb"), ("bBBoA", "bbboo"), ("pBaAA", "ppaaa"), ("pBBBB", "ppppp")]

首先，让我们从定义玩具谐波类开始。

specifications = {("a", "o"):"A", ("b", "p"):"B"}

现在，让我们生成训练样本。

num_examples  =  10 
len_examples  =  5 
S  =  generate_pairs ( num_examples ,  len_examples ,  Specifications ) 
show  =  5 
print ( show ,  "first pairs of S: \n " ,  S [: show ]) 
5  first  pair  of  S : 
 [( 'bBaBA' ,  'bbaba' ),  ( 'abBAB' ,  'abbab' ),  ( 'aApBB' , 'aapp' ),  ( 'pBoBB'

SigmaPie 0.5

导航

项目链接

统计数据

Meta

Maintainers

分类