文档结构  
翻译进度:已翻译     翻译赏金:0 元 (?)    ¥ 我要打赏

Lango

Lango 是一个自然语言处理库,用于构建语言的基础。包含如下工具:

安装

使用 pip 安全

pip install lango

下载斯坦福模型和解析器

确保你已经安装了 Java 开发工具包,斯坦福解析器需要 Java 。

下载斯坦福解析器

设置环境变量

设置环境变量 STANFORD_PARSER 和 STANFORD_MODELS 到解析器的下载路径

import os
os.environ['STANFORD_PARSER'] = 'stanford-parser-full-2015-12-09'
os.environ['STANFORD_MODELS'] = 'stanford-parser-full-2015-12-09'
第 1 段(可获 2 积分)

文档

Matching 匹配

匹配是通过一个解析树对一组规则的比较和匹配。你可以在 examples/parser_input.py 源码中查看一些语句的解析树示例。

规则是递归的,可以匹配解析树中的多个部分。

规则可以拆分成多个更小的子规则,包括:

  • Tag
  • Token
  • Token Tree
  • Rules

Tag 标签

tag 是一个待匹配的 POS (发音部) . 斯坦福解析器所使用的一组 POS 标签可从这里 获取.

Format:
tag = string

Example:
'NP'
'VP'
'PP'

Token 令牌

令牌是一个包含了用于匹配的标签和修饰符/标签的字符串。我们指定一个  match_label 方法来匹配标签。我们也可以为每个树中提取的字符串指定参数。我们可以为匹配树到字符串指定 eq,这些参数包括:

第 2 段(可获 2 积分)

参数:

  • -o 获取对象 (删除 the, a, an 等单词)
  • -w 获取整个树,小写的
  • -p  获取完整单词,并保持大小写一致
Format:
token = tag:match_label-opts
token = tag:match_label-opts=eq

Example: 
'NP:subject-o'
'VP'
'NP:np'
'VP=run'
'VP:action=run'

令牌树

令牌树相当于令牌的递归树,树匹配解析树的结构。

Format:
token_tree = ( token token_tree token_tree ... )

Examples: 
'( NP ( DT ) ( NP:subject-o ) )'
'( NP )'
'( PP ( TO=to ) ( NP:object-o ) )'

规则

规则是令牌树的字典并与一个嵌套规则匹配标签对应。

第 3 段(可获 2 积分)
Format:
rules = {token_tree: {match_label: rules}}

Example: 
{
    '( S ( NP:np ) ( VP ( VBD:action-o ) ( PP:pp ) ) )': {
        'np': {
            '( NP:subject-o )': {}
        },
        'pp': {
            '( PP ( TO=to ) ( NP:to_object-o ) )': {},
            '( PP ( IN=from ) ( NP:from_object-o ) )': {},
        }
    },
}

当匹配一个规则到解析树时,首先匹配的是令牌树,然后所有的匹配标签根据响应的匹配 label 被匹配到嵌套规则中。

所有嵌套的匹配 label 必须有一个子规则匹配,要不就是规则不匹配。

第 4 段(可获 2 积分)

返回了首个要匹配的规则,因此匹配的顺序是基于关键字排序(如果是有序匹配则使用的是 OrderedDict ). 一旦某个规则匹配到,会调用回调函数,并传递 context 作为参数。

示例

假设我们有个句子 "Sam ran to his house" 然后我们需要匹配主题 ("Sam"), 以及目标 ("his house") 和动作 ("ran").

根据斯坦福解析器,上述的解析树如下:

(S
  (NP 
    (NNP Sam)
    )
  (VP
    (VBD ran)
      (PP 
        (TO to)
        (NP
          (PRP$ his)
          (NN house)
          )
        )
    )
  )
第 5 段(可获 2 积分)

简化的树形状:

tree

Matching:
Parse Tree: 
(S (NP (NNP Sam) ) (VP (VBD ran) (PP (TO to) (NP (PRP$ his) (NN house))))

Matched token tree: '( S ( NP:np ) ( VP ( VBD:action-o ) ( PP:pp ) ) )'
Matched context: 
  np: (NP (NNP Sam))
  action-o: 'ran'
  pp: (PP (TO to) (NP (PRP$ his) (NN house)))

 '( S ( NP:np ) ( VP ( VBD:action-o ) ( PP:pp ) ) )' 规则:

tree

匹配 'NP' 和整个 NP 树匹配,并转成一个单词:

Matched token tree for np: '( NP:subject-o )'
Matched context:
  subject-o: 'Sam'

匹配 'PP' 邀请匹配嵌套规则:

第 6 段(可获 2 积分)
Match token tree for pp: '( PP ( TO=to ) ( NP:to_object-o ) )'
Match context:
  object-o: 'his house'

Match token tree for pp: '( PP ( IN=from ) ( NP:from_object-o ) )'
No match found

PP 样本句子:

tree

嵌套 PP 规则:

treetree

只有首个规则匹配用于 PP。

现在我们已经匹配了所有的嵌套规则,我们可以返回 context:

Returned context:
  action: 'ran'
  subject: 'sam'
  to_object: 'his house'

Full code:

from lango.parser import StanfordLibParser
from lango.matcher import match_rules

parser = StanfordLibParser()

rules = {
  '( S ( NP:np ) ( VP ( VBD:action-o ) ( PP:pp ) ) )': {
    'np': {
        '( NP:subject-o )': {}
    },
    'pp': {
        '( PP ( TO=to ) ( NP:to_object-o ) )': {},
        '( PP ( IN=from ) ( NP:from_object-o ) )': {}
    }
  }
}

def fun(subject, action, to_object=None, from_object=None):
    print "%s,%s,%s,%s" % (subject, action, to_object, from_object)

tree = parser.parse('Sam ran to his house')
match_rules(tree, rules, fun)
# output should be: sam, ran, his house, None

tree = parser.parse('Billy walked from his apartment')
match_rules(tree, rules, fun)
# output should be: billy, walked, None, his apartment
第 7 段(可获 2 积分)

文章评论