• 从文本提取信息(基于nltk)


    对于任何给定的问题,很可能已经有人把答案写在某个地方了。以电子形式提供的自然语言文本的数量真的惊人,并且与日俱增。然而,自然语言的复杂性使访问这些文本中的信息非常困难。NLP 目前的技术水平仍然有很长的路要走才能够从不受限制的文本对意义建立通用的表示。如果我们不是集中我们的精力在问题或“实体关系”的有限集合,例如:“不同的设施位于何处”或“谁被什么公司雇用”上,我们就能取得重大进展。本章的目的是要回答下列问题:

    1. 我们如何能构建一个系统,从非结构化文本中提取结构化数据如表格?
    2. 有哪些稳健的方法识别一个文本中描述的实体和关系?
    3. 哪些语料库适合这项工作,我们如何使用它们来训练和评估我们的模型?

    一路上,我们将应用前面两章中的技术来解决分块和命名实体识别

    1 信息提取

    信息有很多种形状和大小。一个重要的形式是结构化数据:实体和关系的可预测的规范的结构。例如,我们可能对公司和地点之间的关系感兴趣。给定一个公司,我们希望能够确定它做业务的位置;反过来,给定位置,我们会想发现哪些公司在该位置做业务。如果我们的数据是表格形式,如 1.1 中的例子,那么回答这些问题就很简单了。

    表 1.1:

    位置数据

    1. >>> locs = [('Omnicom', 'IN', 'New York'),
    2. ... ('DDB Needham', 'IN', 'New York'),
    3. ... ('Kaplan Thaler Group', 'IN', 'New York'),
    4. ... ('BBDO South', 'IN', 'Atlanta'),
    5. ... ('Georgia-Pacific', 'IN', 'Atlanta')]
    6. >>> query = [e1 for (e1, rel, e2) in locs if e2=='Atlanta']
    7. >>> print(query)
    8. ['BBDO South', 'Georgia-Pacific']

    表 1.2:

    在亚特兰大运营的公司

    1. >>> def ie_preprocess(document):
    2. ... sentences = nltk.sent_tokenize(document)
    3. ... sentences = [nltk.word_tokenize(sent) for sent in sentences]
    4. ... sentences = [nltk.pos_tag(sent) for sent in sentences]

    注意

    请记住我们的例子程序假设你以import nltk, re, pprint开始交互式会话或程序。

    接下来,命名实体识别中,我们分割和标注可能组成一个有趣关系的实体。通常情况下,这些将被定义为名词短语,例如the knights who say "ni"或者适当的名称如Monty Python。在一些任务中,同时考虑不明确的名词或名词块也是有用的,如every studentcats,这些不必要一定与确定的NP和适当名称一样的方式指示实体。

    最后,在提取关系时,我们搜索对文本中出现在附近的实体对之间的特殊模式,并使用这些模式建立元组记录实体之间的关系。

    2 词块划分

    我们将用于实体识别的基本技术是词块划分,它分割和标注多词符的序列,如 2.1 所示。小框显示词级分词和词性标注,大框显示高级别的词块划分。每个这种较大的框叫做一个词块。就像分词忽略空白符,词块划分通常选择词符的一个子集。同样像分词一样,词块划分器生成的片段在源文本中不能重叠。

     图 2.1:词符和词块级别的分割与标注

    在本节中,我们将在较深的层面探讨词块划分,以词块的定义和表示开始。我们将看到正则表达式和 N 元的方法来词块划分,使用 CoNLL-2000 词块划分语料库开发和评估词块划分器。我们将在(5)和 6 回到命名实体识别和关系抽取的任务。

    2.1 名词短语词块划分

    我们将首先思考名词短语词块划分或NP词块划分任务,在那里我们寻找单独名词短语对应的词块。例如,这里是一些《华尔街日报》文本,其中的NP词块用方括号标记:

    1. >>> sentence = [("the", "DT"), ("little", "JJ"), ("yellow", "JJ"),
    2. ... ("dog", "NN"), ("barked", "VBD"), ("at", "IN"), ("the", "DT"), ("cat", "NN")]
    3. >>> grammar = "NP: {
      ?*}"
    4. >>> cp = nltk.RegexpParser(grammar)
    5. >>> result = cp.parse(sentence)
    6. >>> print(result)
    7. (S
    8. (NP the/DT little/JJ yellow/JJ dog/NN)
    9. barked/VBD
    10. at/IN
    11. (NP the/DT cat/NN))
    12. >>> result.draw()

    2.2 标记模式

    组成一个词块语法的规则使用标记模式来描述已标注的词的序列。一个标记模式是一个词性标记序列,用尖括号分隔,如

    ?>JJ>*>NN>。标记模式类似于正则表达式模式(3.4)。现在,思考下面的来自《华尔街日报》的名词短语:

    1. another/DT sharp/JJ dive/NN
    2. trade/NN figures/NNS
    3. any/DT new/JJ policy/NN measures/NNS
    4. earlier/JJR stages/NNS
    5. Panamanian/JJ dictator/NN Manuel/NNP Noriega/NNP

    2.3 用正则表达式进行词块划分

    要找到一个给定的句子的词块结构,RegexpParser词块划分器以一个没有词符被划分的平面结构开始。词块划分规则轮流应用,依次更新词块结构。一旦所有的规则都被调用,返回生成的词块结构。

    2.3 显示了一个由 2 个规则组成的简单的词块语法。第一条规则匹配一个可选的限定词或所有格代名词,零个或多个形容词,然后跟一个名词。第二条规则匹配一个或多个专有名词。我们还定义了一个进行词块划分的例句❶,并在此输入上运行这个词块划分器❷。

    1. grammar = r"""
    2. NP: {?*} # chunk determiner/possessive, adjectives and noun
    3. {+} # chunk sequences of proper nouns
    4. """
    5. cp = nltk.RegexpParser(grammar)
    6. sentence = [("Rapunzel", "NNP"), ("let", "VBD"), ("down", "RP"),
    7. ("her", "PP$"), ("long", "JJ"), ("golden", "JJ"), ("hair", "NN")]

    注意

    `

    如果标记模式匹配位置重叠,最左边的匹配优先。例如,如果我们应用一个匹配两个连续的名词文本的规则到一个包含三个连续的名词的文本,则只有前两个名词将被划分:

    1. >>> nouns = [("money", "NN"), ("market", "NN"), ("fund", "NN")]
    2. >>> grammar = "NP: {} # Chunk two consecutive nouns"
    3. >>> cp = nltk.RegexpParser(grammar)
    4. >>> print(cp.parse(nouns))
    5. (S (NP money/NN market/NN) fund/NN)

    一旦我们创建了money market词块,我们就已经消除了允许fund被包含在一个词块中的上下文。这个问题可以避免,使用一种更加宽容的块规则,如NP: {>NN>+}

    注意

    我们已经为每个块规则添加了一个注释。这些是可选的;当它们的存在时,词块划分器将它作为其跟踪输出的一部分输出这些注释。

    2.4 探索文本语料库

    在 2 中,我们看到了我们如何在已标注的语料库中提取匹配的特定的词性标记序列的短语。我们可以使用词块划分器更容易的做同样的工作,如下:

    1. >>> cp = nltk.RegexpParser('CHUNK: { }')
    2. >>> brown = nltk.corpus.brown
    3. >>> for sent in brown.tagged_sents():
    4. ... tree = cp.parse(sent)
    5. ... for subtree in tree.subtrees():
    6. ... if subtree.label() == 'CHUNK': print(subtree)
    7. ...
    8. (CHUNK combined/VBN to/TO achieve/VB)
    9. (CHUNK continue/VB to/TO place/VB)
    10. (CHUNK serve/VB to/TO protect/VB)
    11. (CHUNK wanted/VBD to/TO wait/VB)
    12. (CHUNK allowed/VBN to/TO place/VB)
    13. (CHUNK expected/VBN to/TO become/VB)
    14. ...
    15. (CHUNK seems/VBZ to/TO overtake/VB)
    16. (CHUNK want/VB to/TO buy/VB)

    注意

    轮到你来:将上面的例子封装在函数find_chunks()内,以一个如"CHUNK: {>V.*> >TO> >V.*>}"的词块字符串作为参数。使用它在语料库中搜索其他几种模式,例如连续四个或多个名词,例如"NOUNS: {>N.*>{4,}}"

    2.5 词缝加塞

    有时定义我们想从一个词块中排除什么比较容易。我们可以定义词缝为一个不包含在词块中的一个词符序列。在下面的例子中,barked/VBD at/IN是一个词缝:

     
    

    2.6 词块的表示:标记与树

    作为标注和分析之间的中间状态(8),词块结构可以使用标记或树来表示。最广泛的文件表示使用 IOB 标记。在这个方案中,每个词符被三个特殊的词块标记之一标注,I(内部),O(外部)或B(开始)。一个词符被标注为B,如果它标志着一个词块的开始。块内的词符子序列被标注为I。所有其他的词符被标注为OBI标记后面跟着词块类型,如B-NPI-NP。当然,没有必要指定出现在词块外的词符类型,所以这些都只标注为O。这个方案的例子如 2.5 所示。

    图 2.5:词块结构的标记表示形式

    IOB 标记已成为文件中表示词块结构的标准方式,我们也将使用这种格式。下面是 2.5 中的信息如何出现在一个文件中的:

    1. We PRP B-NP
    2. saw VBD O
    3. the DT B-NP
    4. yellow JJ I-NP
    5. dog NN I-NP
    复制ErrorOK!

    注意

    NLTK 使用树作为词块的内部表示,并提供这些树与 IOB 格式互换的方法。

    3 开发和评估词块划分器

    现在你对分块的作用有了一些了解,但我们并没有解释如何评估词块划分器。和往常一样,这需要一个合适的已标注语料库。我们一开始寻找将 IOB 格式转换成 NLTK 树的机制,然后是使用已化分词块的语料库如何在一个更大的规模上做这个。我们将看到如何为一个词块划分器相对一个语料库的准确性打分,再看看一些数据驱动方式搜索NP词块。我们整个的重点在于扩展一个词块划分器的覆盖范围。

    3.1 读取 IOB 格式与 CoNLL2000 语料库

    使用corpus模块,我们可以加载已经标注并使用 IOB 符号划分词块的《华尔街日报》文本。这个语料库提供的词块类型有NPVPPP。正如我们已经看到的,每个句子使用多行表示,如下所示:

    1. he PRP B-NP
    2. accepted VBD B-VP
    3. the DT B-NP
    4. position NN I-NP
    5. ...
    复制ErrorOK!

    我们可以使用 NLTK 的corpus模块访问较大量的已经划分词块的文本。CoNLL2000 语料库包含 27 万词的《华尔街日报文本》,分为“训练”和“测试”两部分,标注有词性标记和 IOB 格式词块标记。我们可以使用nltk.corpus.conll2000访问这些数据。下面是一个读取语料库的“训练”部分的第 100 个句子的例子:

    1. >>> from nltk.corpus import conll2000
    2. >>> print(conll2000.chunked_sents('train.txt')[99])
    3. (S
    4. (PP Over/IN)
    5. (NP a/DT cup/NN)
    6. (PP of/IN)
    7. (NP coffee/NN)
    8. ,/,
    9. (NP Mr./NNP Stone/NNP)
    10. (VP told/VBD)
    11. (NP his/PRPc194a9eg<!-- begin-inline-katex story/NN)
    12. ./.)
    复制ErrorOK!

    正如你看到的,CoNLL2000 语料库包含三种词块类型:NP词块,我们已经看到了;VP词块如has already deliveredPP块如because of。因为现在我们唯一感兴趣的是NP词块,我们可以使用chunk_types参数选择它们:

    1. >>> print(conll2000.chunked_sents('train.txt', chunk_types=['NP'])[99])
    2. (S
    3. Over/IN
    4. (NP a/DT cup/NN)
    5. of/IN
    6. (NP coffee/NN)
    7. ,/,
    8. (NP Mr./NNP Stone/NNP)
    9. told/VBD
    10. (NP his/PRPend-inline-katex--> story/NN)
    11. ./.)
    复制ErrorOK!

    3.2 简单的评估和基准

    现在,我们可以访问一个已划分词块语料,可以评估词块划分器。我们开始为没有什么意义的词块解析器cp建立一个基准,它不划分任何词块:

    1. >>> from nltk.corpus import conll2000
    2. >>> cp = nltk.RegexpParser("")
    3. >>> test_sents = conll2000.chunked_sents('test.txt', chunk_types=['NP'])
    4. >>> print(cp.evaluate(test_sents))
    5. ChunkParse score:
    6. IOB Accuracy: 43.4%
    7. Precision: 0.0%
    8. Recall: 0.0%
    9. F-Measure: 0.0%
    复制ErrorOK!

    IOB 标记准确性表明超过三分之一的词被标注为O,即没有在NP词块中。然而,由于我们的标注器没有找到任何词块,其精度、召回率和 F 度量均为零。现在让我们尝试一个初级的正则表达式词块划分器,查找以名词短语标记的特征字母开头的标记(如CDDTJJ)。

    1. >>> grammar = r"NP: {<[CDJNP].*>+}"
    2. >>> cp = nltk.RegexpParser(grammar)
    3. >>> print(cp.evaluate(test_sents))
    4. ChunkParse score:
    5. IOB Accuracy: 87.7%
    6. Precision: 70.6%
    7. Recall: 67.8%
    8. F-Measure: 69.2%
    复制ErrorOK!

    正如你看到的,这种方法达到相当好的结果。但是,我们可以采用更多数据驱动的方法改善它,在这里我们使用训练语料找到对每个词性标记最有可能的块标记(IOB)。换句话说,我们可以使用一元标注器(4)建立一个词块划分器。但不是尝试确定每个词的正确的词性标记,而是根据每个词的词性标记,尝试确定正确的词块标记。

    在 3.1 中,我们定义了UnigramChunker类,使用一元标注器给句子加词块标记。这个类的大部分代码只是用来在 NLTK 的ChunkParserI接口使用的词块树表示和嵌入式标注器使用的 IOB 表示之间镜像转换。类定义了两个方法:一个构造函数❶,当我们建立一个新的UnigramChunker时调用;以及parse方法❸,用来给新句子划分词块。

    1. class UnigramChunker(nltk.ChunkParserI):
    2. def __init__(self, train_sents): ❶
    3. train_data = [[(t,c) for w,t,c in nltk.chunk.tree2conlltags(sent)]
    4. for sent in train_sents]
    5. self.tagger = nltk.UnigramTagger(train_data) ❷
    6. def parse(self, sentence): ❸
    7. pos_tags = [pos for (word,pos) in sentence]
    8. tagged_pos_tags = self.tagger.tag(pos_tags)
    9. chunktags = [chunktag for (pos, chunktag) in tagged_pos_tags]
    10. conlltags = [(word, pos, chunktag) for ((word,pos),chunktag)
    11. in zip(sentence, chunktags)]
    12. return nltk.chunk.conlltags2tree(conlltags)
    复制ErrorOK!

    构造函数❶需要训练句子的一个列表,这将是词块树的形式。它首先将训练数据转换成适合训练标注器的形式,使用tree2conlltags映射每个词块树到一个word,tag,chunk三元组的列表。然后使用转换好的训练数据训练一个一元标注器,并存储在self.tagger供以后使用。

    parse方法❸接收一个已标注的句子作为其输入,以从那句话提取词性标记开始。它然后使用在构造函数中训练过的标注器self.tagger,为词性标记标注 IOB 词块标记。接下来,它提取词块标记,与原句组合,产生conlltags。最后,它使用conlltags2tree将结果转换成一个词块树。

    现在我们有了UnigramChunker,可以使用 CoNLL2000 语料库训练它,并测试其表现:

    1. >>> test_sents = conll2000.chunked_sents('test.txt', chunk_types=['NP'])
    2. >>> train_sents = conll2000.chunked_sents('train.txt', chunk_types=['NP'])
    3. >>> unigram_chunker = UnigramChunker(train_sents)
    4. >>> print(unigram_chunker.evaluate(test_sents))
    5. ChunkParse score:
    6. IOB Accuracy: 92.9%
    7. Precision: 79.9%
    8. Recall: 86.8%
    9. F-Measure: 83.2%
    复制ErrorOK!

    这个分块器相当不错,达到整体 F 度量 83% 的得分。让我们来看一看通过使用一元标注器分配一个标记给每个语料库中出现的词性标记,它学到了什么:

    1. >>> postags = sorted(set(pos for sent in train_sents
    2. ... for (word,pos) in sent.leaves()))
    3. >>> print(unigram_chunker.tagger.tag(postags))
    4. [('#', 'B-NP'), ('c194a9eg', 'B-NP'),
    5. ('RB', 'O'), ('RBR', 'O'), ('RBS', 'B-NP'), ('RP', 'O'), ('SYM', 'O'),
    6. ('TO', 'O'), ('UH', 'O'), ('VB', 'O'), ('VBD', 'O'), ('VBG', 'O'),
    7. ('VBN', 'O'), ('VBP', 'O'), ('VBZ', 'O'), ('WDT', 'B-NP'),
    8. ('WP', 'B-NP'), ('WPc194a9eg} # Chunk verbs and their arguments
    9. CLAUSE: {} # Chunk NP, VP
    10. """
    11. cp = nltk.RegexpParser(grammar)
    12. sentence = [("Mary", "NN"), ("saw", "VBD"), ("the", "DT"), ("cat", "NN"),
    13. ("sit", "VB"), ("on", "IN"), ("the", "DT"), ("mat", "NN")]
    复制ErrorOK!

    不幸的是,这一结果丢掉了saw为首的VP。它还有其他缺陷。当我们将此词块划分器应用到一个有更深嵌套的句子时,让我们看看会发生什么。请注意,它无法识别❶开始的VP词块。

    1. >>> sentence = [("John", "NNP"), ("thinks", "VBZ"), ("Mary", "NN"),
    2. ... ("saw", "VBD"), ("the", "DT"), ("cat", "NN"), ("sit", "VB"),
    3. ... ("on", "IN"), ("the", "DT"), ("mat", "NN")]
    4. >>> print(cp.parse(sentence))
    5. (S
    6. (NP John/NNP)
    7. thinks/VBZ
    8. (NP Mary/NN)
    9. saw/VBD # [_saw-vbd]
    10. (CLAUSE
    11. (NP the/DT cat/NN)
    12. (VP sit/VB (PP on/IN (NP the/DT mat/NN)))))
    复制ErrorOK!

    这些问题的解决方案是让词块划分器在它的模式中循环:尝试完所有模式之后,重复此过程。我们添加一个可选的第二个参数loop指定这套模式应该循环的次数:

    1. >>> cp = nltk.RegexpParser(grammar, loop=2)
    2. >>> print(cp.parse(sentence))
    3. (S
    4. (NP John/NNP)
    5. thinks/VBZ
    6. (CLAUSE
    7. (NP Mary/NN)
    8. (VP
    9. saw/VBD
    10. (CLAUSE
    11. (NP the/DT cat/NN)
    12. (VP sit/VB (PP on/IN (NP the/DT mat/NN)))))))
    复制ErrorOK!

    注意

    这个级联过程使我们能创建深层结构。然而,创建和调试级联过程是困难的,关键点是它能更有效地做全面的分析(见第 8 章)。另外,级联过程只能产生固定深度的树(不超过级联级数),完整的句法分析这是不够的。

    4.2 Trees

    树是一组连接的加标签节点,从一个特殊的根节点沿一条唯一的路径到达每个节点。下面是一棵树的例子(注意它们标准的画法是颠倒的):

    1. (S
    2. (NP Alice)
    3. (VP
    4. (V chased)
    5. (NP
    6. (Det the)
    7. (N rabbit))))
    复制ErrorOK!

    虽然我们将只集中关注语法树,树可以用来编码任何同构的超越语言形式序列的层次结构(如形态结构、篇章结构)。一般情况下,叶子和节点值不一定要是字符串。

    在 NLTK 中,我们通过给一个节点添加标签和一系列的孩子创建一棵树:

    1. >>> tree1 = nltk.Tree('NP', ['Alice'])
    2. >>> print(tree1)
    3. (NP Alice)
    4. >>> tree2 = nltk.Tree('NP', ['the', 'rabbit'])
    5. >>> print(tree2)
    6. (NP the rabbit)
    复制ErrorOK!

    我们可以将这些不断合并成更大的树,如下所示:

    1. >>> tree3 = nltk.Tree('VP', ['chased', tree2])
    2. >>> tree4 = nltk.Tree('S', [tree1, tree3])
    3. >>> print(tree4)
    4. (S (NP Alice) (VP chased (NP the rabbit)))
    复制ErrorOK!

    下面是树对象的一些的方法:

    1. >>> print(tree4[1])
    2. (VP chased (NP the rabbit))
    3. >>> tree4[1].label()
    4. 'VP'
    5. >>> tree4.leaves()
    6. ['Alice', 'chased', 'the', 'rabbit']
    7. >>> tree4[1][1][1]
    8. 'rabbit'
    复制ErrorOK!

    复杂的树用括号表示难以阅读。在这些情况下,draw方法是非常有用的。它会打开一个新窗口,包含树的一个图形表示。树显示窗口可以放大和缩小,子树可以折叠和展开,并将图形表示输出为一个 postscript 文件(包含在一个文档中)。

    >>> tree3.draw()                           复制ErrorOK!

    4.3 树遍历

    使用递归函数来遍历树是标准的做法。4.2 中的内容进行了演示。

    1. def traverse(t):
    2. try:
    3. t.label()
    4. except AttributeError:
    5. print(t, end=" ")
    6. else:
    7. # Now we know that t.node is defined
    8. print('(', t.label(), end=" ")
    9. for child in t:
    10. traverse(child)
    11. print(')', end=" ")
    12. >>> t = nltk.Tree('(S (NP Alice) (VP chased (NP the rabbit)))')
    13. >>> traverse(t)
    14. ( S ( NP Alice ) ( VP chased ( NP the rabbit ) ) )
    复制ErrorOK!

    注意

    我们已经使用了一种叫做动态类型的技术,检测t是一棵树(如定义了t.label())。

    5 命名实体识别

    在本章开头,我们简要介绍了命名实体(NE)。命名实体是确切的名词短语,指示特定类型的个体,如组织、人、日期等。5.1 列出了一些较常用的 NE 类型。这些应该是不言自明的,除了FACILITY:建筑和土木工程领域的人造产品;以及GPE:地缘政治实体,如城市、州/省、国家。

    表 5.1:

    常用命名实体类型

    1. Eddy N B-PER
    2. Bonte N I-PER
    3. is V O
    4. woordvoerder N O
    5. van Prep O
    6. diezelfde Pron O
    7. Hogeschool N B-ORG
    8. . Punc O
    复制ErrorOK!
    1. >>> print(nltk.ne_chunk(sent))
    2. (S
    3. The/DT
    4. (GPE U.S./NNP)
    5. is/VBZ
    6. one/CD
    7. ...
    8. according/VBG
    9. to/TO
    10. (PERSON Brooke/NNP T./NNP Mossman/NNP)
    11. ...)
    复制ErrorOK!

    6 关系抽取

    一旦文本中的命名实体已被识别,我们就可以提取它们之间存在的关系。如前所述,我们通常会寻找指定类型的命名实体之间的关系。进行这一任务的方法之一是首先寻找所有X, α, Y)形式的三元组,其中XY是指定类型的命名实体,α表示XY之间关系的字符串。然后我们可以使用正则表达式从α的实体中抽出我们正在查找的关系。下面的例子搜索包含词in的字符串。特殊的正则表达式(?!\b.+ing\b)是一个否定预测先行断言,允许我们忽略如success in supervising the transition of中的字符串,其中in后面跟一个动名词。

    1. >>> IN = re.compile(r'.*\bin\b(?!\b.+ing)')
    2. >>> for doc in nltk.corpus.ieer.parsed_docs('NYT_19980315'):
    3. ... for rel in nltk.sem.extract_rels('ORG', 'LOC', doc,
    4. ... corpus='ieer', pattern = IN):
    5. ... print(nltk.sem.rtuple(rel))
    6. [ORG: 'WHYY'] 'in' [LOC: 'Philadelphia']
    7. [ORG: 'McGlashan & Sarrail'] 'firm in' [LOC: 'San Mateo']
    8. [ORG: 'Freedom Forum'] 'in' [LOC: 'Arlington']
    9. [ORG: 'Brookings Institution'] ', the research group in' [LOC: 'Washington']
    10. [ORG: 'Idealab'] ', a self-described business incubator based in' [LOC: 'Los Angeles']
    11. [ORG: 'Open Text'] ', based in' [LOC: 'Waterloo']
    12. [ORG: 'WGBH'] 'in' [LOC: 'Boston']
    13. [ORG: 'Bastille Opera'] 'in' [LOC: 'Paris']
    14. [ORG: 'Omnicom'] 'in' [LOC: 'New York']
    15. [ORG: 'DDB Needham'] 'in' [LOC: 'New York']
    16. [ORG: 'Kaplan Thaler Group'] 'in' [LOC: 'New York']
    17. [ORG: 'BBDO South'] 'in' [LOC: 'Atlanta']
    18. [ORG: 'Georgia-Pacific'] 'in' [LOC: 'Atlanta']
    复制ErrorOK!

    搜索关键字in执行的相当不错,虽然它的检索结果也会误报,例如[ORG: House Transportation Committee] , secured the most money in the [LOC: New York];一种简单的基于字符串的方法排除这样的填充字符串似乎不太可能。

    如前文所示,conll2002命名实体语料库的荷兰语部分不只包含命名实体标注,也包含词性标注。这允许我们设计对这些标记敏感的模式,如下面的例子所示。clause()方法以分条形式输出关系,其中二元关系符号作为参数relsym的值被指定❶。

    1. >>> from nltk.corpus import conll2002
    2. >>> vnv = """
    3. ... (
    4. ... is/V| # 3rd sing present and
    5. ... was/V| # past forms of the verb zijn ('be')
    6. ... werd/V| # and also present
    7. ... wordt/V # past of worden ('become)
    8. ... )
    9. ... .* # followed by anything
    10. ... van/Prep # followed by van ('of')
    11. ... """
    12. >>> VAN = re.compile(vnv, re.VERBOSE)
    13. >>> for doc in conll2002.chunked_sents('ned.train'):
    14. ... for r in nltk.sem.extract_rels('PER', 'ORG', doc,
    15. ... corpus='conll2002', pattern=VAN):
    16. ... print(nltk.sem.clause(r, relsym="VAN")) ❶
    17. VAN("cornet_d'elzius", 'buitenlandse_handel')
    18. VAN('johan_rottiers', 'kardinaal_van_roey_instituut')
    19. VAN('annie_lennox', 'eurythmics')
    复制ErrorOK!

    注意

    轮到你来:替换最后一行❶为print(rtuple(rel, lcon=True, rcon=True))。这将显示实际的词表示两个 NE 之间关系以及它们左右的默认 10 个词的窗口的上下文。在一本荷兰语词典的帮助下,你也许能够找出为什么结果VAN('annie_lennox', 'eurythmics')是个误报。

    7 小结

    • 信息提取系统搜索大量非结构化文本,寻找特定类型的实体和关系,并用它们来填充有组织的数据库。这些数据库就可以用来寻找特定问题的答案。
    • 信息提取系统的典型结构以断句开始,然后是分词和词性标注。接下来在产生的数据中搜索特定类型的实体。最后,信息提取系统着眼于文本中提到的相互临近的实体,并试图确定这些实体之间是否有指定的关系。
    • 实体识别通常采用词块划分器,它分割多词符序列,并用适当的实体类型给它们加标签。常见的实体类型包括组织、人员、地点、日期、时间、货币、GPE(地缘政治实体)。
    • 用基于规则的系统可以构建词块划分器,例如 NLTK 中提供的RegexpParser类;或使用机器学习技术,如本章介绍的ConsecutiveNPChunker。在这两种情况中,词性标记往往是搜索词块时的一个非常重要的特征。
    • 虽然词块划分器专门用来建立相对平坦的数据结构,其中没有任何两个词块允许重叠,但它们可以被串联在一起,建立嵌套结构。
    • 关系抽取可以使用基于规则的系统,它通常查找文本中的连结实体和相关的词的特定模式;或使用机器学习系统,通常尝试从训练语料自动学习这种模式。

    8 深入阅读

    本章的附加材料发布在http://nltk.org/,包括网络上免费提供的资源的链接。关于使用 NLTK 词块划分的更多的例子,请看在http://nltk.org/howto上的词块划分 HOWTO。

    分块的普及很大一部分是由于 Abney 的开创性的工作,如(Church, Young, & Bloothooft, 1996)。http://www.vinartus.net/spa/97a.pdf中描述了 Abney 的 Cass 词块划分器器。

    根据 Ross 和 Tukey 在 1975 年的论文(Church, Young, & Bloothooft, 1996),单词词缝最初的意思是一个停用词序列。

    IOB 格式(有时也称为 BIO 格式)由(Ramshaw & Marcus, 1995)开发用来NP划分词块,并被由《Conference on Natural Language Learning》在 1999 年用于NP加括号共享任务。CoNLL 2000 采用相同的格式标注了华尔街日报的文本作为一个NP词块划分共享任务的一部分。

    (Jurafsky & Martin, 2008)的 13.5 节包含有关词块划分的一个讨论。第 22 章讲述信息提取,包括命名实体识别。有关生物学和医学中的文本挖掘的信息,请参阅(Ananiadou & McNaught, 2006)。

  • 相关阅读:
    实验记录:搭建网络过程
    智能化新十年,“全栈智能”定义行业“Copilot智能助手”
    ECMAScript6介绍及环境搭建
    2022年数据泄露平均成本高达435万美元,创历史新高!
    SpringBoot SpringBoot 开发实用篇 3 测试 3.4 发送虚拟请求
    【Audio】正弦波生成原理及C++代码
    《vue3实战》运用push()方法实现电影评价系统的添加功能
    java计算机毕业设计项目任务跟踪系统MyBatis+系统+LW文档+源码+调试部署
    R语言诊断ARIMA模型:forecast包构建了一个ARIMA模型、使用checkresiduals函数诊断ARIMA模型
    圆弧插补-逐点比较法
  • 原文地址:https://blog.csdn.net/sikh_0529/article/details/126845555