NLTK学习笔记(七):文本信息提取

梦里梦外; 2022-05-16 00:49 403阅读 0赞

*  [实体识别：分块技术][Link 1]
    
     *  [分块语法的构建][Link 2]
     *  [树状图][Link 3]
     *  [IOB标记][IOB]
 *  [开发和评估分块器][Link 4]
 *  [命名实体识别和信息提取][Link 5]

> 如何构建一个系统，用于从非结构化的文本中提取结构化的信息和数据？哪些方法使用这类行为？哪些语料库适合这项工作？是否可以训练和评估模型？

**信息提取，特别是结构化信息提取，可以类比数据库的记录。对应的关系绑定了对应的数据信息。针对自然语言这类非结构化的数据，为了获取对应关系，应该搜索实体对应的特殊关系，并且用字符串、元素等一些数据结构记录。**

## 实体识别：分块技术 ##

比如：We saw the yellow dog ，按照分块的思想，会将后三个词语分到NP中，而里面的三个词又分别对应 DT/JJ/NN；saw 分到VBD中；We 分到NP中。对于最后三个词语来说，NP就是组块（较大的集合）。为了做到这点，可以**借助NLTK自带的分块语法，类似于正则表达式，来实现句子分块。**

### 分块语法的构建 ###

注意三点即可：

*  基本的分块：`组块 :{组块下的子组块}`（类似于：`"NP: {<DT>?<JJ>*<NN>}"`这样的字符串）。而?\*+保存了正则表达式的意义。

import nltk
    sentence = [('the','DT'),('little','JJ'),('yellow','JJ'),('dog','NN'),('brak','VBD')]
    grammer = "NP: {<DT>?<JJ>*<NN>}"
    cp = nltk.RegexpParser(grammer) #生成规则
    result = cp.parse(sentence) #进行分块
    print(result)
    
    result.draw() #调用matplotlib库画出来

*  可以为不包括再大块中的标识符序列定义一个**缝隙**：`}<VBD|IN>+{`

import nltk
    sentence = [('the','DT'),('little','JJ'),('yellow','JJ'),('dog','NN'),('bark','VBD'),('at','IN'),('the','DT'),('cat','NN')]
    grammer = """NP: 
                {<DT>?<JJ>*<NN>}
                }<VBD|NN>+{
                """  #加缝隙，必须保存换行符
    cp = nltk.RegexpParser(grammer) #生成规则
    result = cp.parse(sentence) #进行分块
    print(result)

*  可以递归式的调用，这符合语言结构中的递归嵌套。例如：`VP: {<NP|PP|CLAUSE>*} PP:{<NN><VP>}` 。此时，`RegexpParser`函数的参数`loop`即可以设置为2，多次循环，来防止遗漏。

### 树状图 ###

如果调用`print(type(result))`查看类型就会发现，是 `nltk.tree.Tree`。从名字看出来这是一种树状结构。`nltk.Tree` 可以实现树状结构，并且支持拼接技术，提供结点的查询和树的绘制。

tree1 = nltk.Tree('NP',['Alick'])
    print(tree1)
    tree2 = nltk.Tree('N',['Alick','Rabbit'])
    print(tree2)
    tree3 = nltk.Tree('S',[tree1,tree2])
    print(tree3.label()) #查看树的结点
    tree3.draw()

### IOB标记 ###

分别代表内部，外部，开始（就是英语单词的首字母）。对于上面讲的 NP，NN这样的分类，只需要在前面加上 I-/B-/O-即可。这样就能使规则外的集合被显式出来，类似上面的加缝隙。

--------------------

## 开发和评估分块器 ##

NLTK已经为我们提供了分块器，减少了手动构建规则。同时，也提供了已经分块好的内容，供我们自己构建规则时候进行参考。

#这段代码在python2下运行
    from nltk.corpus import conll2000
    print conll2000.chunked_sents('train.txt')[99] #查看已经分块的一个句子
    
    text = """
       he /PRP/ B-NP
       accepted /VBD/ B-VP
       the DT B-NP
       position NN I-NP
       of IN B-PP
       vice NN B-NP
       chairman NN I-NP
       of IN B-PP
       Carlyle NNP B-NP
       Group NNP I-NP
       , , O
       a DT B-NP
       merchant NN I-NP
       banking NN I-NP
       concern NN I-NP
       . . O
    """
    result = nltk.chunk.conllstr2tree(text,chunk_types=['NP'])

对于之前自己定义的规则`cp`，可以使用`cp.evaluate(conll2000.chunked_sents('train.txt')[99])` 来测试正确率。利用之前学过的Unigram标注器，可以进行名词短语分块，并且测试准确度

class UnigramChunker(nltk.ChunkParserI):
        """
            一元分块器，
            该分块器可以从训练句子集中找出每个词性标注最有可能的分块标记，
            然后使用这些信息进行分块
        """
        def __init__(self, train_sents):
            """
                构造函数
                :param train_sents: Tree对象列表
            """
            train_data = []
            for sent in train_sents:
                # 将Tree对象转换为IOB标记列表[(word, tag, IOB-tag), ...]
                conlltags = nltk.chunk.tree2conlltags(sent)
    
                # 找出每个词性标注对应的IOB标记
                ti_list = [(t, i) for w, t, i in conlltags]
                train_data.append(ti_list)
    
            # 使用一元标注器进行训练
            self.__tagger = nltk.UnigramTagger(train_data)
    
        def parse(self, tokens):
            """
                对句子进行分块
                :param tokens: 标注词性的单词列表
                :return: Tree对象
            """
            # 取出词性标注
            tags = [tag for (word, tag) in tokens]
            # 对词性标注进行分块标记
            ti_list = self.__tagger.tag(tags)
            # 取出IOB标记
            iob_tags = [iob_tag for (tag, iob_tag) in ti_list]
            # 组合成conll标记
            conlltags = [(word, pos, iob_tag) for ((word, pos), iob_tag) in zip(tokens, iob_tags)]
    
            return nltk.chunk.conlltags2tree(conlltags)
    test_sents = conll2000.chunked_sents("test.txt", chunk_types=["NP"])
    train_sents = conll2000.chunked_sents("train.txt", chunk_types=["NP"])
    
    unigram_chunker = UnigramChunker(train_sents)
    print(unigram_chunker.evaluate(test_sents))

## 命名实体识别和信息提取 ##

**命名实体：确切的名词短语，指特定类型的个体，如日期、人、组织等** 。如果自己去许梿分类器肯定头大(ˉ▽￣～)~~。NLTK提供了一个训练好的分类器--`nltk.ne_chunk(tagged_sent[,binary=False])` 。如果binary被设置为True，那么命名实体就只被标注为NE；否则标签会有点复杂。

sent = nltk.corpus.treebank.tagged_sents()[22]
    print(nltk.ne_chunk(sent,binary=True))

如果命名实体被确定后，就可以实现**关系抽取**来提取信息。一种方法是：寻找所有的三元组(X,a,Y)。其中X和Y是命名实体，a是表示两者关系的字符串，示例如下：

#请在Python2下运行
    import re
    IN = re.compile(r'.*\bin\b(?!\b.+ing)')
    for doc in nltk.corpus.ieer.parsed_docs('NYT_19980315'):
        for rel in nltk.sem.extract_rels('ORG','LOC',doc,corpus='ieer',pattern = IN):
            print nltk.sem.show_raw_rtuple(rel)

[Link 1]: https://www.cnblogs.com/AsuraDong/p/7050859.html#%E5%AE%9E%E4%BD%93%E8%AF%86%E5%88%AB%E5%88%86%E5%9D%97%E6%8A%80%E6%9C%AF
[Link 2]: https://www.cnblogs.com/AsuraDong/p/7050859.html#%E5%88%86%E5%9D%97%E8%AF%AD%E6%B3%95%E7%9A%84%E6%9E%84%E5%BB%BA
[Link 3]: https://www.cnblogs.com/AsuraDong/p/7050859.html#%E6%A0%91%E7%8A%B6%E5%9B%BE
[IOB]: https://www.cnblogs.com/AsuraDong/p/7050859.html#iob%E6%A0%87%E8%AE%B0
[Link 4]: https://www.cnblogs.com/AsuraDong/p/7050859.html#%E5%BC%80%E5%8F%91%E5%92%8C%E8%AF%84%E4%BC%B0%E5%88%86%E5%9D%97%E5%99%A8
[Link 5]: https://www.cnblogs.com/AsuraDong/p/7050859.html#%E5%91%BD%E5%90%8D%E5%AE%9E%E4%BD%93%E8%AF%86%E5%88%AB%E5%92%8C%E4%BF%A1%E6%81%AF%E6%8F%90%E5%8F%96