自然语言具有范围广泛的语法结构，用8.中所描述的简单的方法很难处理的如此广泛的语法结构。为了获得更大的灵活性，我们改变我们对待语法类别如S、NP和V的方式。我们将这些原子标签分解为类似字典的结构，其特征可以为一个范围的值。

本章的目的是要回答下列问题：

  1. 我们怎样用特征扩展上下文无关语法框架，以获得更细粒度的对语法类别和产生式的控制？
  2. 特征结构的主要形式化属性是什么，我们如何使用它们来计算？
  3. 我们现在用基于特征的语法能捕捉到什么语言模式和语法结构？

一路上，我们将介绍更多的英语句法主题，包括约定、子类别和无限制依赖成分等现象。

1 语法特征

在chap-data-intensive中，我们描述了如何建立基于检测文本特征的分类器。那些特征可能非常简单，如提取一个单词的最后一个字母，或者更复杂一点儿，如分类器自己预测的词性标签。在本章中，我们将探讨特征在建立基于规则的语法中的作用。对比特征提取，记录已经自动检测到的特征，我们现在要 声明 词和短语的特征。我们以一个很简单的例子开始，使用字典存储特征和它们的值。

  1. >>> kim = {'CAT': 'NP', 'ORTH': 'Kim', 'REF': 'k'}
  2. >>> chase = {'CAT': 'V', 'ORTH': 'chased', 'REL': 'chase'}

对象kim和chase有几个共同的特征，CAT（语法类别）和ORTH（正字法，即拼写）。此外，每一个还有更面向语义的特征：kim['REF']意在给出kim的指示物，而chase['REL']给出chase表示的关系。在基于规则的语法上下文中，这样的特征和特征值对被称为特征结构，我们将很快看到它们的替代符号。

特征结构包含各种有关语法实体的信息。这些信息不需要详尽无遗，我们可能要进一步增加属性。例如，对于一个动词，根据动词的参数知道它扮演的“语义角色”往往很有用。对于 chase，主语扮演“施事”的角色，而宾语扮演“受事”角色。让我们添加这些信息，使用'sbj'和'obj'作为占位符，它会被填充，当动词和它的语法参数结合时：

  1. >>> chase['AGT'] = 'sbj'
  2. >>> chase['PAT'] = 'obj'

如果我们现在处理句子Kim chased Lee，我们要“绑定”动词的施事角色和主语，受事角色和宾语。我们可以通过链接到相关的NP的REF特征做到这个。在下面的例子中，我们做一个简单的假设：在动词直接左侧和右侧的NP分别是主语和宾语。我们还在例子结尾为 Lee 添加了一个特征结构。

  1. >>> sent = "Kim chased Lee"
  2. >>> tokens = sent.split()
  3. >>> lee = {'CAT': 'NP', 'ORTH': 'Lee', 'REF': 'l'}
  4. >>> def lex2fs(word):
  5. ...     for fs in [kim, lee, chase]:
  6. ...         if fs['ORTH'] == word:
  7. ...             return fs
  8. >>> subj, verb, obj = lex2fs(tokens[0]), lex2fs(tokens[1]), lex2fs(tokens[2])
  9. >>> verb['AGT'] = subj['REF']
  10. >>> verb['PAT'] = obj['REF']
  11. >>> for k in ['ORTH', 'REL', 'AGT', 'PAT']:
  12. ...     print("%-5s => %s" % (k, verb[k]))
  13. ORTH  => chased
  14. REL   => chase
  15. AGT   => k
  16. PAT   => l

同样的方法可以适用不同的动词，例如 surprise，虽然在这种情况下，主语将扮演“源事”（SRC）的角色，宾语扮演“体验者”（EXP）的角色：

  1. >>> surprise = {'CAT': 'V', 'ORTH': 'surprised', 'REL': 'surprise',
  2. ...             'SRC': 'sbj', 'EXP': 'obj'}

特征结构是非常强大的，但我们操纵它们的方式是极其 ad hoc。我们本章接下来的任务是，显示上下文无关语法和分析如何能扩展到合适的特征结构，使我们可以一种更通用的和有原则的方式建立像这样的分析。我们将通过查看句法协议的现象作为开始；我们将展示如何使用特征典雅的表示协议约束，并在一个简单的语法中说明它们的用法。

由于特征结构是表示任何形式的信息的通用的数据结构，我们将从更形式化的视点简要地看着它们，并演示 NLTK 提供的特征结构的支持。在本章的最后一部分，我们将表明，特征的额外表现力开辟了一个用于描述语言结构的复杂性的广泛的可能性。

1.1 句法协议

下面的例子展示词序列对，其中第一个是符合语法的而第二个不是。（我们在词序列的开头用星号表示它是不符合语法的。）

  1. S   ->   NP VP
  2. NP  ->   Det N
  3. VP  ->   V
  5. Det  ->  'this'
  6. N    ->  'dog'
  7. V    ->  'runs'

1.2 使用属性和约束

我们说过非正式的语言类别具有 属性 ；例如，名词具有复数的属性。让我们把这个弄的更明确：

  1. N[NUM=pl]

注意一个句法类别可以有多个特征，例如V[TENSE=pres, NUM=pl]。在一般情况下，我们喜欢多少特征就可以添加多少。

关于1.1的最后的细节是语句%start S。这个“指令”告诉分析器以S作为文法的开始符号。

一般情况下，即使我们正在尝试开发很小的语法，把产生式放在一个文件中我们可以编辑、测试和修改是很方便的。我们将1.1以 NLTK 的数据格式保存为文件'feat0.fcfg'。你可以使用nltk.data.load()制作你自己的副本进行进一步的实验。

1.2 说明了基于特征的语法图表解析的操作。为输入分词之后，我们导入load_parser函数9\. 构建基于特征的语法 - 图1，以语法文件名为输入，返回一个图表分析器cp 9\. 构建基于特征的语法 - 图2。调用分析器的parse()方法将迭代生成的分析树；如果文法无法分析输入，trees将为空，并将会包含一个或多个分析树，取决于输入是否有句法歧义。

  1. >>> tokens = 'Kim likes children'.split()
  2. >>> from nltk import load_parser ![[1]](Images/77460905bcad52d84e324fc4821ed903.jpg)
  3. >>> cp = load_parser('grammars/book_grammars/feat0.fcfg', trace=2)  ![[2]](Images/07e7d99633e4a107388f7202380cce55.jpg)
  4. >>> for tree in cp.parse(tokens):
  5. ...     print(tree)
  6. ...
  7. |.Kim .like.chil.|
  8. Leaf Init Rule:
  9. |[----]    .    .| [0:1] 'Kim'
  10. |.    [----]    .| [1:2] 'likes'
  11. |.    .    [----]| [2:3] 'children'
  12. Feature Bottom Up Predict Combine Rule:
  13. |[----]    .    .| [0:1] PropN[NUM='sg'] -> 'Kim' *
  14. Feature Bottom Up Predict Combine Rule:
  15. |[----]    .    .| [0:1] NP[NUM='sg'] -> PropN[NUM='sg'] *
  16. Feature Bottom Up Predict Combine Rule:
  17. |[---->    .    .| [0:1] S[] -> NP[NUM=?n] * VP[NUM=?n] {?n: 'sg'}
  18. Feature Bottom Up Predict Combine Rule:
  19. |.    [----]    .| [1:2] TV[NUM='sg', TENSE='pres'] -> 'likes' *
  20. Feature Bottom Up Predict Combine Rule:
  21. |.    [---->    .| [1:2] VP[NUM=?n, TENSE=?t] -> TV[NUM=?n, TENSE=?t] * NP[] {?n: 'sg', ?t: 'pres'}
  22. Feature Bottom Up Predict Combine Rule:
  23. |.    .    [----]| [2:3] N[NUM='pl'] -> 'children' *
  24. Feature Bottom Up Predict Combine Rule:
  25. |.    .    [----]| [2:3] NP[NUM='pl'] -> N[NUM='pl'] *
  26. Feature Bottom Up Predict Combine Rule:
  27. |.    .    [---->| [2:3] S[] -> NP[NUM=?n] * VP[NUM=?n] {?n: 'pl'}
  28. Feature Single Edge Fundamental Rule:
  29. |.    [---------]| [1:3] VP[NUM='sg', TENSE='pres'] -> TV[NUM='sg', TENSE='pres'] NP[] *
  30. Feature Single Edge Fundamental Rule:
  31. |[==============]| [0:3] S[] -> NP[NUM='sg'] VP[NUM='sg'] *
  32. (S[]
  33.   (NP[NUM='sg'] (PropN[NUM='sg'] Kim))
  34.   (VP[NUM='sg', TENSE='pres']
  35.     (TV[NUM='sg', TENSE='pres'] likes)
  36.     (NP[NUM='pl'] (N[NUM='pl'] children))))

分析过程中的细节对于当前的目标并不重要。然而，有一个实施上的问题与我们前面的讨论语法的大小有关。分析包含特征限制的产生式的一种可行的方法是编译出问题中特征的所有可接受的值，是我们最终得到一个大的完全指定的(6)中那样的 CFG。相比之下，前面例子中显示的分析器过程直接与给定语法的未指定的产生式一起运作。特征值从词汇条目“向上流动”，变量值于是通过如{?n: 'sg', ?t: 'pres'}这样的绑定（即字典）与那些值关联起来。当分析器装配有关它正在建立的树的节点的信息时，这些变量绑定被用来实例化这些节点中的值；从而通过查找绑定中?n和?t的值，未指定的VP[NUM=?n, TENSE=?t] -> TV[NUM=?n, TENSE=?t] NP[]实例化为VP[NUM='sg', TENSE='pres'] -> TV[NUM='sg', TENSE='pres'] NP[]。

最后，我们可以检查生成的分析树（在这种情况下，只有一个）。

  1. >>> for tree in trees: print(tree)
  2. (S[]
  3.  (NP[NUM='sg'] (PropN[NUM='sg'] Kim))
  4.  (VP[NUM='sg', TENSE='pres']
  5.  (TV[NUM='sg', TENSE='pres'] likes)
  6.  (NP[NUM='pl'] (N[NUM='pl'] children))))

1.3 术语

到目前为止，我们只看到像sg和pl这样的特征值。这些简单的值通常被称为原子——也就是，它们不能被分解成更小的部分。原子值的一种特殊情况是布尔值，也就是说，值仅仅指定一个属性是真还是假。例如，我们可能要用布尔特征AUX区分助动词，如 can，may，will 和 do。例如，产生式V[TENSE=pres, AUX=+] -> 'can'意味着 can 接受TENSE的值为pres，并且AUX的值为+或true。有一个广泛采用的约定用缩写表示布尔特征f；不用AUX=+或AUX=-，我们分别用+AUX和-AUX。这些都是缩写，然而，分析器就像+和-是其他原子值一样解释它们。(15)显示了一些有代表性的产生式：

  1. V[TENSE=pres, +AUX] -> 'can'
  2. V[TENSE=pres, +AUX] -> 'may'
  4. V[TENSE=pres, -AUX] -> 'walks'
  5. V[TENSE=pres, -AUX] -> 'likes'

在传递中，我们应该指出有显示 AVM 的替代方法；1.3显示了一个例子。虽然特征结构呈现的(16)中的风格不太悦目，我们将坚持用这种格式，因为它对应我们将会从 NLTK 得到的输出。

关于表示，我们也注意到特征结构，像字典，对特征的 顺序 没有指定特别的意义。所以(16)等同于︰

  1. [AGR = [NUM = pl  ]]
  2. [      [PER = 3   ]]
  3. [      [GND = fem ]]
  4. [                  ]
  5. [POS = N           ]

2 处理特征结构

在本节中，我们将展示如何在 NLTK 中构建和操作特征结构。我们还将讨论统一的基本操作，这使我们能够结合两个不同的特征结构中的信息。

NLTK 中的特征结构使用构造函数FeatStruct()声明。原子特征值可以是字符串或整数。

  1. >>> fs1 = nltk.FeatStruct(TENSE='past', NUM='sg')
  2. >>> print(fs1)
  3. [ NUM   = 'sg'   ]
  4. [ TENSE = 'past' ]

一个特征结构实际上只是一种字典，所以我们可以平常的方式通过索引访问它的值。我们可以用我们熟悉的方式 赋 值给特征：

  1. >>> fs1 = nltk.FeatStruct(PER=3, NUM='pl', GND='fem')
  2. >>> print(fs1['GND'])
  3. fem
  4. >>> fs1['CASE'] = 'acc'

我们还可以为特征结构定义更复杂的值，如前面所讨论的。

  1. >>> fs2 = nltk.FeatStruct(POS='N', AGR=fs1)
  2. >>> print(fs2)
  3. [       [ CASE = 'acc' ] ]
  4. [ AGR = [ GND  = 'fem' ] ]
  5. [       [ NUM  = 'pl'  ] ]
  6. [       [ PER  = 3     ] ]
  7. [                        ]
  8. [ POS = 'N'              ]
  9. >>> print(fs2['AGR'])
  10. [ CASE = 'acc' ]
  11. [ GND  = 'fem' ]
  12. [ NUM  = 'pl'  ]
  13. [ PER  = 3     ]
  14. >>> print(fs2['AGR']['PER'])
  15. 3

指定特征结构的另一种方法是使用包含feature=value格式的特征-值对的方括号括起的字符串，其中值本身可能是特征结构：

  1. >>> print(nltk.FeatStruct("[POS='N', AGR=[PER=3, NUM='pl', GND='fem']]"))
  2. [       [ GND = 'fem' ] ]
  3. [ AGR = [ NUM = 'pl'  ] ]
  4. [       [ PER = 3     ] ]
  5. [                       ]
  6. [ POS = 'N'             ]

特征结构本身并不依赖于语言对象；它们是表示知识的通用目的的结构。例如，我们可以将一个人的信息用特征结构编码：

  1. >>> print(nltk.FeatStruct(NAME='Lee', TELNO='01 27 86 42 96', AGE=33))
  2. [ AGE   = 33               ]
  3. [ NAME  = 'Lee'            ]
  4. [ TELNO = '01 27 86 42 96' ]

在接下来的几页中，我们会使用这样的例子来探讨特征结构的标准操作。这将使我们暂时从自然语言处理转移，因为在我们回来谈论语法之前需要打下基础。坚持！

将特征结构作为图来查看往往是有用的；更具体的，作为有向无环图（DAG）。(19)等同于上面的 AVM。

  1. >>> print(nltk.FeatStruct("""[NAME='Lee', ADDRESS=(1)[NUMBER=74, STREET='rue Pascal'],
  2. ...                          SPOUSE=[NAME='Kim', ADDRESS->(1)]]"""))
  3. [ ADDRESS = (1) [ NUMBER = 74           ] ]
  4. [               [ STREET = 'rue Pascal' ] ]
  5. [                                         ]
  6. [ NAME    = 'Lee'                         ]
  7. [                                         ]
  8. [ SPOUSE  = [ ADDRESS -> (1)  ]           ]
  9. [           [ NAME    = 'Kim' ]           ]

括号内的整数有时也被称为标记或同指标志。整数的选择并不重要。可以有任意数目的标记在一个单独的特征结构中。

  1. >>> print(nltk.FeatStruct("[A='a', B=(1)[C='c'], D->(1), E->(1)]"))
  2. [ A = 'a'             ]
  3. [                     ]
  4. [ B = (1) [ C = 'c' ] ]
  5. [                     ]
  6. [ D -> (1)            ]
  7. [ E -> (1)            ]

2.1 包含和统一

认为特征结构提供一些对象的部分信息是很正常的，在这个意义上，我们可以根据它们通用的程度给特征结构排序。例如，(23a)比(23b)具有更少特征，(23b)比(23c)具有更少特征。

  1. [NUMBER = 74]

统一被正式定义为一个（部分）二元操作：FS0 ⊔ FS1。统一是对称的，所以 FS0 ⊔ FS1 = FS1 ⊔ FS0。在 Python 中也是如此：

  1. >>> print(fs2.unify(fs1))
  2. [ CITY   = 'Paris'      ]
  3. [ NUMBER = 74           ]
  4. [ STREET = 'rue Pascal' ]

如果我们统一两个具有包含关系的特征结构，那么统一的结果是两个中更具体的那个：

  1. >>> fs0 = nltk.FeatStruct(A='a')
  2. >>> fs1 = nltk.FeatStruct(A='b')
  3. >>> fs2 = fs0.unify(fs1)
  4. >>> print(fs2)
  5. None

现在，如果我们看一下统一如何与结构共享相互作用，事情就变得很有趣。首先，让我们在 Python 中定义(21)：

  1. >>> fs0 = nltk.FeatStruct("""[NAME=Lee,
  2. ...                           ADDRESS=[NUMBER=74,
  3. ...                                    STREET='rue Pascal'],
  4. ...                           SPOUSE= [NAME=Kim,
  5. ...                                    ADDRESS=[NUMBER=74,
  6. ...                                             STREET='rue Pascal']]]""")
  7. >>> print(fs0)
  8. [ ADDRESS = [ NUMBER = 74           ]               ]
  9. [           [ STREET = 'rue Pascal' ]               ]
  10. [                                                   ]
  11. [ NAME    = 'Lee'                                   ]
  12. [                                                   ]
  13. [           [ ADDRESS = [ NUMBER = 74           ] ] ]
  14. [ SPOUSE  = [           [ STREET = 'rue Pascal' ] ] ]
  15. [           [                                     ] ]
  16. [           [ NAME    = 'Kim'                     ] ]

我们为 Kim 的地址指定一个CITY作为参数会发生什么？请注意，fs1需要包括从特征结构的根到CITY的整个路径。

  1. >>> fs1 = nltk.FeatStruct("[SPOUSE = [ADDRESS = [CITY = Paris]]]")
  2. >>> print(fs1.unify(fs0))
  3. [ ADDRESS = [ NUMBER = 74           ]               ]
  4. [           [ STREET = 'rue Pascal' ]               ]
  5. [                                                   ]
  6. [ NAME    = 'Lee'                                   ]
  7. [                                                   ]
  8. [           [           [ CITY   = 'Paris'      ] ] ]
  9. [           [ ADDRESS = [ NUMBER = 74           ] ] ]
  10. [ SPOUSE  = [           [ STREET = 'rue Pascal' ] ] ]
  11. [           [                                     ] ]
  12. [           [ NAME    = 'Kim'                     ] ]

通过对比，如果fs1与fs2的结构共享版本统一，结果是非常不同的（如图(22)所示）：

  1. >>> fs2 = nltk.FeatStruct("""[NAME=Lee, ADDRESS=(1)[NUMBER=74, STREET='rue Pascal'],
  2. ...                           SPOUSE=[NAME=Kim, ADDRESS->(1)]]""")
  3. >>> print(fs1.unify(fs2))
  4. [               [ CITY   = 'Paris'      ] ]
  5. [ ADDRESS = (1) [ NUMBER = 74           ] ]
  6. [               [ STREET = 'rue Pascal' ] ]
  7. [                                         ]
  8. [ NAME    = 'Lee'                         ]
  9. [                                         ]
  10. [ SPOUSE  = [ ADDRESS -> (1)  ]           ]
  11. [           [ NAME    = 'Kim' ]           ]

不是仅仅更新 Kim 的 Lee 的地址的“副本”，我们现在同时更新他们两个的地址。更一般的，如果统一包含指定一些路径π的值，那么统一同时更新等价于π的任何路径的值。

正如我们已经看到的，结构共享也可以使用变量表示，如?x。

  1. >>> fs1 = nltk.FeatStruct("[ADDRESS1=[NUMBER=74, STREET='rue Pascal']]")
  2. >>> fs2 = nltk.FeatStruct("[ADDRESS1=?x, ADDRESS2=?x]")
  3. >>> print(fs2)
  4. [ ADDRESS1 = ?x ]
  5. [ ADDRESS2 = ?x ]
  6. >>> print(fs2.unify(fs1))
  7. [ ADDRESS1 = (1) [ NUMBER = 74           ] ]
  8. [                [ STREET = 'rue Pascal' ] ]
  9. [                                          ]
  10. [ ADDRESS2 -> (1)                          ]

3 扩展基于特征的语法

在本节中，我们回到基于特征的语法，探索各种语言问题，并展示将特征纳入语法的好处。

3.1 子类别

第8.中，我们增强了类别标签表示不同类别的动词，分别用标签IV和TV表示不及物动词和及物动词。这使我们能编写如下的产生式：

  1. VP -> IV
  2. VP -> TV NP

3.2 核心词回顾

我们注意到，在上一节中，通过从主类别标签分解出子类别信息，我们可以表达有关动词属性的更多概括。类似的另一个属性如下：V类的表达式是VP类的短语的核心。同样，N是NP的核心词，A（即形容词）是AP的核心词，P（即介词）是PP的核心词。并非所有的短语都有核心词——例如，一般认为连词短语（如 the book and the bell）缺乏核心词——然而，我们希望我们的语法形式能表达它所持有的父母/核心子女关系。现在，V和VP只是原子符号，我们需要找到一种方法用特征将它们关联起来（就像我们以前关联IV和TV那样）。

X-bar 句法通过抽象出短语级别的概念，解决了这个问题。它通常认为有三个这样的级别。如果N表示词汇级别，那么N‘表示更高一层级别，对应较传统的级别Nom，N‘’表示短语级别，对应类别NP。(34a)演示了这种表示结构，而(34b)是更传统的对应。

  1. S -> N[BAR=2] V[BAR=2]
  2. N[BAR=2] -> Det N[BAR=1]
  3. N[BAR=1] -> N[BAR=1] P[BAR=2]
  4. N[BAR=1] -> N[BAR=0] P[BAR=2]
  5. N[BAR=1] -> N[BAR=0]XS

3.3 助动词与倒装

倒装从句——其中的主语和动词顺序互换——出现在英语疑问句，也出现在“否定”副词之后：

  1. S[+INV] -> V[+AUX] NP VP

3.4 无限制依赖成分

考虑下面的对比：

  1. >>> nltk.data.show_cfg('grammars/book_grammars/feat1.fcfg')
  2. % start S
  3. # ###################
  4. # Grammar Productions
  5. # ###################
  6. S[-INV] -> NP VP
  7. S[-INV]/?x -> NP VP/?x
  8. S[-INV] -> NP S/NP
  9. S[-INV] -> Adv[+NEG] S[+INV]
  10. S[+INV] -> V[+AUX] NP VP
  11. S[+INV]/?x -> V[+AUX] NP VP/?x
  12. SBar -> Comp S[-INV]
  13. SBar/?x -> Comp S[-INV]/?x
  14. VP -> V[SUBCAT=intrans, -AUX]
  15. VP -> V[SUBCAT=trans, -AUX] NP
  16. VP/?x -> V[SUBCAT=trans, -AUX] NP/?x
  17. VP -> V[SUBCAT=clause, -AUX] SBar
  18. VP/?x -> V[SUBCAT=clause, -AUX] SBar/?x
  19. VP -> V[+AUX] VP
  20. VP/?x -> V[+AUX] VP/?x
  21. # ###################
  22. # Lexical Productions
  23. # ###################
  24. V[SUBCAT=intrans, -AUX] -> 'walk' | 'sing'
  25. V[SUBCAT=trans, -AUX] -> 'see' | 'like'
  26. V[SUBCAT=clause, -AUX] -> 'say' | 'claim'
  27. V[+AUX] -> 'do' | 'can'
  28. NP[-WH] -> 'you' | 'cats'
  29. NP[+WH] -> 'who'
  30. Adv[+NEG] -> 'rarely' | 'never'
  31. NP/NP ->
  32. Comp -> 'that'

3.1中的语法包含一个“缺口引进”产生式，即S[-INV] -> NP S/NP。为了正确的预填充斜线特征，我们需要为扩展S，VP和NP的产生式中箭头两侧的斜线添加变量值。例如，VP/?x -> V SBar/?x是VP -> V SBar的斜线版本，也就是说，可以为一个成分的父母VP指定斜线值，只要也为孩子SBar指定同样的值。最后，NP/NP ->允许NP上的斜线信息为空字符串。使用3.1中的语法，我们可以分析序列 who do you claim that you like

  1. >>> tokens = 'who do you claim that you like'.split()
  2. >>> from nltk import load_parser
  3. >>> cp = load_parser('grammars/book_grammars/feat1.fcfg')
  4. >>> for tree in cp.parse(tokens):
  5. ...     print(tree)
  6. (S[-INV]
  7.  (NP[+WH] who)
  8.  (S[+INV]/NP[]
  9.  (V[+AUX] do)
  10.  (NP[-WH] you)
  11.  (VP[]/NP[]
  12.  (V[-AUX, SUBCAT='clause'] claim)
  13.  (SBar[]/NP[]
  14.  (Comp[] that)
  15.  (S[-INV]/NP[]
  16.  (NP[-WH] you)
  17.  (VP[]/NP[] (V[-AUX, SUBCAT='trans'] like) (NP[]/NP[] )))))))

这棵树的一个更易读的版本如(52)所示。

  1. >>> tokens = 'you claim that you like cats'.split()
  2. >>> for tree in cp.parse(tokens):
  3. ...     print(tree)
  4. (S[-INV]
  5.  (NP[-WH] you)
  6.  (VP[]
  7.  (V[-AUX, SUBCAT='clause'] claim)
  8.  (SBar[]
  9.  (Comp[] that)
  10.  (S[-INV]
  11.  (NP[-WH] you)
  12.  (VP[] (V[-AUX, SUBCAT='trans'] like) (NP[-WH] cats))))))

此外，它还允许没有 wh 结构的倒装句：

  1. >>> tokens = 'rarely do you sing'.split()
  2. >>> for tree in cp.parse(tokens):
  3. ...     print(tree)
  4. (S[-INV]
  5.  (Adv[+NEG] rarely)
  6.  (S[+INV]
  7.  (V[+AUX] do)
  8.  (NP[-WH] you)
  9.  (VP[] (V[-AUX, SUBCAT='intrans'] sing))))

3.5 德语中的格和性别

与英语相比，德语的协议具有相对丰富的形态。例如，在德语中定冠词根据格、性别和数量变化，如3.1所示。

表 3.1：

德语定冠词的形态范式

  1. >>> nltk.data.show_cfg('grammars/book_grammars/german.fcfg')
  2. % start S
  3.  # Grammar Productions
  4.  S -> NP[CASE=nom, AGR=?a] VP[AGR=?a]
  5.  NP[CASE=?c, AGR=?a] -> PRO[CASE=?c, AGR=?a]
  6.  NP[CASE=?c, AGR=?a] -> Det[CASE=?c, AGR=?a] N[CASE=?c, AGR=?a]
  7.  VP[AGR=?a] -> IV[AGR=?a]
  8.  VP[AGR=?a] -> TV[OBJCASE=?c, AGR=?a] NP[CASE=?c]
  9.  # Lexical Productions
  10.  # Singular determiners
  11.  # masc
  12.  Det[CASE=nom, AGR=[GND=masc,PER=3,NUM=sg]] -> 'der'
  13.  Det[CASE=dat, AGR=[GND=masc,PER=3,NUM=sg]] -> 'dem'
  14.  Det[CASE=acc, AGR=[GND=masc,PER=3,NUM=sg]] -> 'den'
  15.  # fem
  16.  Det[CASE=nom, AGR=[GND=fem,PER=3,NUM=sg]] -> 'die'
  17.  Det[CASE=dat, AGR=[GND=fem,PER=3,NUM=sg]] -> 'der'
  18.  Det[CASE=acc, AGR=[GND=fem,PER=3,NUM=sg]] -> 'die'
  19.  # Plural determiners
  20.  Det[CASE=nom, AGR=[PER=3,NUM=pl]] -> 'die'
  21.  Det[CASE=dat, AGR=[PER=3,NUM=pl]] -> 'den'
  22.  Det[CASE=acc, AGR=[PER=3,NUM=pl]] -> 'die'
  23.  # Nouns
  24.  N[AGR=[GND=masc,PER=3,NUM=sg]] -> 'Hund'
  25.  N[CASE=nom, AGR=[GND=masc,PER=3,NUM=pl]] -> 'Hunde'
  26.  N[CASE=dat, AGR=[GND=masc,PER=3,NUM=pl]] -> 'Hunden'
  27.  N[CASE=acc, AGR=[GND=masc,PER=3,NUM=pl]] -> 'Hunde'
  28.  N[AGR=[GND=fem,PER=3,NUM=sg]] -> 'Katze'
  29.  N[AGR=[GND=fem,PER=3,NUM=pl]] -> 'Katzen'
  30.  # Pronouns
  31.  PRO[CASE=nom, AGR=[PER=1,NUM=sg]] -> 'ich'
  32.  PRO[CASE=acc, AGR=[PER=1,NUM=sg]] -> 'mich'
  33.  PRO[CASE=dat, AGR=[PER=1,NUM=sg]] -> 'mir'
  34.  PRO[CASE=nom, AGR=[PER=2,NUM=sg]] -> 'du'
  35.  PRO[CASE=nom, AGR=[PER=3,NUM=sg]] -> 'er' | 'sie' | 'es'
  36.  PRO[CASE=nom, AGR=[PER=1,NUM=pl]] -> 'wir'
  37.  PRO[CASE=acc, AGR=[PER=1,NUM=pl]] -> 'uns'
  38.  PRO[CASE=dat, AGR=[PER=1,NUM=pl]] -> 'uns'
  39.  PRO[CASE=nom, AGR=[PER=2,NUM=pl]] -> 'ihr'
  40.  PRO[CASE=nom, AGR=[PER=3,NUM=pl]] -> 'sie'
  41.  # Verbs
  42.  IV[AGR=[NUM=sg,PER=1]] -> 'komme'
  43.  IV[AGR=[NUM=sg,PER=2]] -> 'kommst'
  44.  IV[AGR=[NUM=sg,PER=3]] -> 'kommt'
  45.  IV[AGR=[NUM=pl, PER=1]] -> 'kommen'
  46.  IV[AGR=[NUM=pl, PER=2]] -> 'kommt'
  47.  IV[AGR=[NUM=pl, PER=3]] -> 'kommen'
  48.  TV[OBJCASE=acc, AGR=[NUM=sg,PER=1]] -> 'sehe' | 'mag'
  49.  TV[OBJCASE=acc, AGR=[NUM=sg,PER=2]] -> 'siehst' | 'magst'
  50.  TV[OBJCASE=acc, AGR=[NUM=sg,PER=3]] -> 'sieht' | 'mag'
  51.  TV[OBJCASE=dat, AGR=[NUM=sg,PER=1]] -> 'folge' | 'helfe'
  52.  TV[OBJCASE=dat, AGR=[NUM=sg,PER=2]] -> 'folgst' | 'hilfst'
  53.  TV[OBJCASE=dat, AGR=[NUM=sg,PER=3]] -> 'folgt' | 'hilft'
  54.  TV[OBJCASE=acc, AGR=[NUM=pl,PER=1]] -> 'sehen' | 'moegen'
  55.  TV[OBJCASE=acc, AGR=[NUM=pl,PER=2]] -> 'sieht' | 'moegt'
  56.  TV[OBJCASE=acc, AGR=[NUM=pl,PER=3]] -> 'sehen' | 'moegen'
  57.  TV[OBJCASE=dat, AGR=[NUM=pl,PER=1]] -> 'folgen' | 'helfen'
  58.  TV[OBJCASE=dat, AGR=[NUM=pl,PER=2]] -> 'folgt' | 'helft'
  59.  TV[OBJCASE=dat, AGR=[NUM=pl,PER=3]] -> 'folgen' | 'helfen'

正如你可以看到的，特征objcase被用来指定动词支配它的对象的格。下一个例子演示了包含支配与格的动词的句子的分析树。

  1. >>> tokens = 'ich folge den Katzen'.split()
  2. >>> cp = load_parser('grammars/book_grammars/german.fcfg')
  3. >>> for tree in cp.parse(tokens):
  4. ...     print(tree)
  5. (S[]
  6.  (NP[AGR=[NUM='sg', PER=1], CASE='nom']
  7.  (PRO[AGR=[NUM='sg', PER=1], CASE='nom'] ich))
  8.  (VP[AGR=[NUM='sg', PER=1]]
  9.  (TV[AGR=[NUM='sg', PER=1], OBJCASE='dat'] folge)
  10.  (NP[AGR=[GND='fem', NUM='pl', PER=3], CASE='dat']
  11.  (Det[AGR=[NUM='pl', PER=3], CASE='dat'] den)
  12.  (N[AGR=[GND='fem', NUM='pl', PER=3]] Katzen))))

在开发语法时，排除不符合语法的词序列往往与分析符合语法的词序列一样具有挑战性。为了能知道在哪里和为什么序列分析失败，设置load_parser()方法的trace参数可能是至关重要的。思考下面的分析故障：

  1. >>> tokens = 'ich folge den Katze'.split()
  2. >>> cp = load_parser('grammars/book_grammars/german.fcfg', trace=2)
  3. >>> for tree in cp.parse(tokens):
  4. ...     print(tree)
  5. |.ich.fol.den.Kat.|
  6. Leaf Init Rule:
  7. |[---]   .   .   .| [0:1] 'ich'
  8. |.   [---]   .   .| [1:2] 'folge'
  9. |.   .   [---]   .| [2:3] 'den'
  10. |.   .   .   [---]| [3:4] 'Katze'
  11. Feature Bottom Up Predict Combine Rule:
  12. |[---]   .   .   .| [0:1] PRO[AGR=[NUM='sg', PER=1], CASE='nom']
  13.  -> 'ich' *
  14. Feature Bottom Up Predict Combine Rule:
  15. |[---]   .   .   .| [0:1] NP[AGR=[NUM='sg', PER=1], CASE='nom'] -> PRO[AGR=[NUM='sg', PER=1], CASE='nom'] *
  16. Feature Bottom Up Predict Combine Rule:
  17. |[--->   .   .   .| [0:1] S[] -> NP[AGR=?a, CASE='nom'] * VP[AGR=?a] {?a: [NUM='sg', PER=1]}
  18. Feature Bottom Up Predict Combine Rule:
  19. |.   [---]   .   .| [1:2] TV[AGR=[NUM='sg', PER=1], OBJCASE='dat'] -> 'folge' *
  20. Feature Bottom Up Predict Combine Rule:
  21. |.   [--->   .   .| [1:2] VP[AGR=?a] -> TV[AGR=?a, OBJCASE=?c] * NP[CASE=?c] {?a: [NUM='sg', PER=1], ?c: 'dat'}
  22. Feature Bottom Up Predict Combine Rule:
  23. |.   .   [---]   .| [2:3] Det[AGR=[GND='masc', NUM='sg', PER=3], CASE='acc'] -> 'den' *
  24. |.   .   [---]   .| [2:3] Det[AGR=[NUM='pl', PER=3], CASE='dat'] -> 'den' *
  25. Feature Bottom Up Predict Combine Rule:
  26. |.   .   [--->   .| [2:3] NP[AGR=?a, CASE=?c] -> Det[AGR=?a, CASE=?c] * N[AGR=?a, CASE=?c] {?a: [NUM='pl', PER=3], ?c: 'dat'}
  27. Feature Bottom Up Predict Combine Rule:
  28. |.   .   [--->   .| [2:3] NP[AGR=?a, CASE=?c] -> Det[AGR=?a, CASE=?c] * N[AGR=?a, CASE=?c] {?a: [GND='masc', NUM='sg', PER=3], ?c: 'acc'}
  29. Feature Bottom Up Predict Combine Rule:
  30. |.   .   .   [---]| [3:4] N[AGR=[GND='fem', NUM='sg', PER=3]] -> 'Katze' *

跟踪中的最后两个Scanner行显示 den 被识别为两个可能的类别：Det[AGR=[GND='masc', NUM='sg', PER=3], CASE='acc']和Det[AGR=[NUM='pl', PER=3], CASE='dat']。我们从3.2中的语法知道Katze的类别是N[AGR=[GND=fem, NUM=sg, PER=3]]。因而，产生式NP[CASE=?c, AGR=?a] -> Det[CASE=?c, AGR=?a] N[CASE=?c, AGR=?a]中没有变量?a的绑定，这将满足这些限制，因为Katze的AGR值将不与 den 的任何一个AGR值统一，也就是[GND='masc', NUM='sg', PER=3]或[NUM='pl', PER=3]。

4 小结

  • 上下文无关语法的传统分类是原子符号。特征结构的一个重要的作用是捕捉精细的区分，否则将需要数量翻倍的原子类别。
  • 通过使用特征值上的变量，我们可以表达语法产生式中的限制，允许不同的特征规格的实现可以相互依赖。
  • 通常情况下，我们在词汇层面指定固定的特征值，限制短语中的特征值与它们的孩子中的对应值统一。
  • 特征值可以是原子的或复杂的。原子值的一个特定类别是布尔值，按照惯例用[+/- f]表示。
  • 两个特征可以共享一个值（原子的或复杂的）。具有共享值的结构被称为重入。共享的值被表示为 AVM 中的数字索引（或标记）。
  • 一个特征结构中的路径是一个特征的元组，对应从图的根开始的弧的序列上的标签。
  • 两条路径是等价的，如果它们共享一个值。
  • 包含的特征结构是偏序的。FS0包含 FS1，当包含在 FS0中的所有信息也出现在 FS1中。
  • 两种结构 FS0和 FS1的统一，如果成功，就是包含 FS0和 FS1的合并信息的特征结构 FS2。
  • 如果统一在 FS 中指定一条路径π，那么它也指定等效与π的每个路径π’。
  • 我们可以使用特征结构建立对大量广泛语言学现象的简洁的分析，包括动词子类别，倒装结构，无限制依赖结构和格支配。

5 深入阅读

本章进一步的材料请参考http://nltk.org/，包括特征结构、特征语法和语法测试套件。

X-bar 句法：(Jacobs & Rosenbaum, 1970), (Jackendoff, 1977)（The primes we use replace Chomsky’s typographically more demanding horizontal bars）。

协议现象的一个很好的介绍，请参阅(Corbett, 2006)。

理论语言学中最初使用特征的目的是捕捉语音的音素特性。例如，音/b/可能会被分解成结构[+labial, +voice]。一个重要的动机是捕捉分割的类别之间的一般性；例如/n/在任一+labial辅音前面被读作/m/。在乔姆斯基语法中，对一些现象，如协议，使用原子特征是很标准的，原子特征也用来捕捉跨句法类别的概括，通过类比与音韵。句法理论中使用特征的一个激进的扩展是广义短语结构语法（GPSG; (Gazdar, Klein, & and, 1985)），特别是在使用带有复杂值的特征。

从计算语言学的角度来看，(Dahl & Saint-Dizier, 1985)提出语言的功能方面可以被属性-值结构的统一捕获，一个类似的方法由(Grosz & Stickel, 1983)在 PATR-II 形式体系中精心设计完成。词汇功能语法（LFG; (Bresnan, 1982)）的早期工作介绍了 f-structure 概念，它的主要目的是表示语法关系和与成分结构短语关联的谓词参数结构。(Shieber, 1986)提供了研究基于特征语法方面的一个极好的介绍。

当研究人员试图为反面例子建模时，特征结构的代数方法的一个概念上的困难出现了。另一种观点，由(Kasper & Rounds, 1986)和(Johnson, 1988)开创，认为语法涉及结构功能的描述而不是结构本身。这些描述使用逻辑操作如合取相结合，而否定仅仅是特征描述上的普通的逻辑运算。这种面向描述的观点对 LFG 从一开始就是不可或缺的（参见(Huang & Chen, 1989)），也被中心词驱动短语结构语法的较高版本采用（HPSG; (Sag & Wasow, 1999)）。http://www.cl.uni-bremen.de/HPSG-Bib/上有 HPSG 文献的全面的参考书目。

本章介绍的特征结构无法捕捉语言信息中重要的限制。例如，有没有办法表达NUM的值只允许是sg和pl，而指定[NUM=masc]是反常的。同样地，我们不能说AGR的复合值必须包含特征PER，NUM和gnd的指定，但不能包含如[SUBCAT=trans]这样的指定。指定类型的特征结构被开发出来弥补这方面的不足。开始，我们规定总是键入特征值。对于原子值，值就是类型。例如，我们可以说NUM的值是类型num。此外，num是NUM最一般类型的值。由于类型按层次结构组织，通过指定NUM的值为num的子类型，即要么是sg要么是pl，我们可以更富含信息。

In the case of complex values, we say that feature structures are themselves typed. So for example the value of AGR will be a feature structure of type AGR. We also stipulate that all and only PER, NUM and GND are appropriate features for a structure of type AGR. 一个早期的关于指定类型的特征结构的很好的总结是(Emele & Zajac, 1990)。一个形式化基础的更全面的检查可以在(Carpenter, 1992)中找到，(Copestake, 2002)重点关注为面向 HPSG 的方法实现指定类型的特征结构。

有很多著作是关于德语的基于特征语法框架上的分析的。(Nerbonne, Netter, & Pollard, 1994)是这个主题的 HPSG 著作的一个好的起点，而(M{“u}ller, 2002)给出 HPSG 中的德语句法非常广泛和详细的分析。

(Jurafsky & Martin, 2008)的第 15 章讨论了特征结构、统一的算法和将统一整合到分析算法中。

6 练习

  1. ☼ 需要什么样的限制才能正确分析词序列，如 I am happy 和 she is happy 而不是_you is happy 或_they am happy？实现英语中动词 be 的现在时态范例的两个解决方案，首先以语法(6)作为起点，然后以语法 (18)为起点。

  2. ☼ 开发1.1中语法的变体，使用特征count来区分下面显示的句子：

    1. fs1 = nltk.FeatStruct("[A = ?x, B= [C = ?x]]")
    2. fs2 = nltk.FeatStruct("[B = [D = d]]")
    3. fs3 = nltk.FeatStruct("[B = [C = d]]")
    4. fs4 = nltk.FeatStruct("[A = (1)[B = b], C->(1)]")
    5. fs5 = nltk.FeatStruct("[A = (1)[D = ?x], C = [E -> (1), F = ?x] ]")
    6. fs6 = nltk.FeatStruct("[A = [D = d]]")
    7. fs7 = nltk.FeatStruct("[A = [D = d], C = [F = [D = d]]]")
    8. fs8 = nltk.FeatStruct("[A = (1)[D = ?x, G = ?x], C = [B = ?x, E -> (1)] ]")
    9. fs9 = nltk.FeatStruct("[A = [B = b], C = [E = [G = e]]]")
    10. fs10 = nltk.FeatStruct("[A = (1)[B = b], C -> (1)]")


在纸上计算下面的统一的结果是什么。（提示：你可能会发现绘制图结构很有用。）

  1. fs1 and fs2
  2. fs1 and fs3
  3. fs4 and fs5
  4. fs5 and fs6
  5. fs5 and fs7
  6. fs8 and fs9
  7. fs8 and fs10

  1. ◑ 列出两个包含[A=?x, B=?x]的特征结构。

  2. ◑ 忽略结构共享，给出一个统一两个特征结构的非正式算法。

  3. ◑ 扩展3.2中的德语语法，使它能处理所谓的动词第二顺位结构，如下所示：
    | (58) | | Heute sieht der Hund die Katze. |

  4. ◑ 同义动词的句法属性看上去略有不同(Levin, 1993)。思考下面的动词 loaded、filled 和 dumped 的语法模式。你能写语法产生式处理这些数据吗？
    | (59) | |
    | a. | | The farmer loaded the cart with sand |
    | b. | | The farmer loaded sand into the cart |
    | c. | | The farmer filled the cart with sand |
    | d. | | The farmer filled sand into the cart |
    | e. | |     The farmer dumped the cart with sand |
    | f. | | The farmer dumped sand into the cart |
    |

  5. ★ 形态范例很少是完全正规的，矩阵中的每个单元的意义有不同的实现。例如，词位 walk 的现在时态词性变化只有两种不同形式：第三人称单数的 walks 和所有其他人称和数量的组合的 walk。一个成功的分析不应该额外要求 6 个可能的形态组合中有 5 个有相同的实现。设计和实施一个方法处理这个问题。

  6. ★ 所谓的核心特征在父节点和核心孩子节点之间共享。例如，TENSE是核心特征，在一个VP和它的核心孩子V之间共享。更多细节见(Gazdar, Klein, & and, 1985)。我们看到的结构中大部分是核心结构——除了SUBCAT和SLASH。由于核心特征的共享是可以预见的，它不需要在语法产生式中明确表示。开发一种方法自动计算核心结构的这种规则行为的比重。

  7. ★ 扩展 NLTK 中特征结构的处理，允许统一值为列表的特征，使用这个来实现一个 HPSG 风格的子类别分析，核心类别的SUBCAT是它的补语的类别和它直接父母的SUBCAT值的连结。

  8. ★ 扩展 NLTK 的特征结构处理，允许带未指定类别的产生式，例如S[-INV] --> ?x S/?x。

  9. ★ 扩展 NLTK 的特征结构处理，允许指定类型的特征结构。

  10. ★ 挑选一些(Huddleston & Pullum, 2002)中描述的文法结构，建立一个基于特征的语法计算它们的比例。

关于本文档…

针对 NLTK 3.0 进行更新。本章来自于 Natural Language Processing with Python，Steven Bird, Ewan Klein 和Edward Loper，Copyright © 2014 作者所有。本章依据 Creative Commons Attribution-Noncommercial-No Derivative Works 3.0 United States License [http://creativecommons.org/licenses/by-nc-nd/3.0/us/] 条款，与 自然语言工具包 [http://nltk.org/] 3.0 版一起发行。

本文档构建于星期三 2015 年 7 月 1 日 12:30:05 AEST