精华内容
下载资源
问答
  • * 从文本内容中提取日期时间 * @param text 包含日期时间的文本(格式:yyyy年MM月dd日HH:mm) * @return 日期时间字符串(yyyy-MM-dd HH:mm) */ public static String getDateTimeFromT

    需求


    需要从文本文件中提取中时间及日期

    代码

    “`java
    /**
    * 从文本内容中提取日期时间
    * @param text 包含日期时间的文本(格式:yyyy年MM月dd日HH:mm)
    * @return 日期时间字符串(yyyy-MM-dd HH:mm)
    */
    public static String getDateTimeFromText(String text){
    if (null == text){
    return “”;
    }

        Pattern p = Pattern.compile("(\\d{4})年(\\d{2})月(\\d{2})日(\\d{2}:\\d{2})");
        Matcher m = p.matcher(text);
    
        if (m.find() && 4 == m.groupCount()){
            return m.group(1) + "-" + m.group(2) + "-" + m.group(3) + " " + m.group(4); 
        } else {
            return "";
        }
    }
    

    “`java

    展开全文
  • NLP入门(十一)从文本中提取时间

    千次阅读 2019-07-14 19:43:13
      在我们的日常生活和工作从文本中提取时间是一项非常基础却重要的工作,因此,本文将介绍如何从文本中有效地提取时间。   举个简单的例子,我们需要下面的文本中提取时间: 6月28日,杭州市统计局权威...

      在我们的日常生活和工作中,从文本中提取时间是一项非常基础却重要的工作,因此,本文将介绍如何从文本中有效地提取时间。
      举个简单的例子,我们需要从下面的文本中提取时间:

    6月28日,杭州市统计局权威公布《2019年5月月报》,杭州市医保参保人数达到1006万,相比于2月份的989万,三个月暴涨16万人参保,傲视新一线城市。

    我们可以从文本有提取6月28日2019年5月2月份这三个有效时间。
      通常情况下,较好的解决思路是利用深度学习模型来识别文本中的时间,通过一定数量的标记文本和合适的模型。本文尝试利用现有的NLP工具来解决如何从文本中提取时间。
      本文使用的工具为哈工大的pyltp,可以在Python的第三方模块中找到,实现下载好分词模型cws.model和词性标注pos.model这两个模型文件。
      话不多说,我们直接上Python代码,如下:

    # -*- coding: utf-8 -*-
    
    import os
    from pyltp import Segmentor
    from pyltp import Postagger
    
    class LTP(object):
        def __init__(self):
            cws_model_path = os.path.join(os.path.dirname(__file__), 'cws.model')  # 分词模型路径,模型名称为`cws.model`
            pos_model_path = os.path.join(os.path.dirname(__file__), 'pos.model')  # 词性标注模型路径,模型名称为`pos.model`
            self.segmentor = Segmentor()  # 初始化实例
            self.segmentor.load(cws_model_path) # 加载模型
            self.postagger = Postagger()  # 初始化实例
            self.postagger.load(pos_model_path)  # 加载模型
    
        # 分词
        def segment(self, text):
            words = list(self.segmentor.segment(text))
            return words
    
        # 词性标注
        def postag(self, words):
            postags = list(self.postagger.postag(words))
            return postags
    
        # 获取文本中的时间
        def get_time(self, text):
    
            # 开始分词及词性标注
            words = self.segment(text)
            postags = self.postag(words)
    
            time_lst = []
    
            i = 0
            for tag, word in zip(postags, words):
                if tag == 'nt':
                    j = i
                    while postags[j] == 'nt' or words[j] in ['至', '到']:
                        j += 1
                    time_lst.append(''.join(words[i:j]))
                i += 1
    
            # 去重子字符串的情形
            remove_lst = []
            for i in time_lst:
                for j in time_lst:
                    if i != j and i in j:
                        remove_lst.append(i)
    
            text_time_lst = []
            for item in time_lst:
                if item not in remove_lst:
                    text_time_lst.append(item)
    
            # print(text_time_lst)
            return text_time_lst
    
        # 释放模型
        def free_ltp(self):
            self.segmentor.release()
            self.postagger.release()
    
    if __name__ == '__main__':
        ltp = LTP()
    
        # 输入文本
        sent = '6月28日,杭州市统计局权威公布《2019年5月月报》,杭州市医保参保人数达到1006万,相比于2月份的989万,三个月暴涨16万人参保,傲视新一线城市。'
        time_lst = ltp.get_time(sent)
        ltp.free_ltp()
    
        # 输出文本中提取的时间
        print('提取时间: %s' % str(time_lst))
    

      接着,我们测试几个例子。

    输入文本为:

    今天,央行举行了2019年6月份金融统计数据解读吹风会,发布了2019年6月份金融统计数据并就当前的一些热点问题进行了解读和回应。

    文本中提取的时间为:

    提取时间: ['今天', '2019年6月份', '2019年6月份', '当前']
    

    输入文本为:

    2006年,上海的国内生产总值达到10296.97亿元,是中国内地第一个GDP突破万亿元的城市。2008年,北京GDP破万亿。两年后,广州GDP超过万亿。2011年,深圳、天津、苏州、重庆4城的GDP也进入了万亿行列。武汉、成都在2014年跻身“万亿俱乐部”,杭州、南京和青岛、无锡和长沙的GDP依次在2015年、2016年和2017年过万亿。宁波和郑州则成为2018年万亿俱乐部的新成员。

    文本中提取的时间为:

    提取时间: ['2006年', '2008年', '2011年', '2014年', '2015年', '2016年', '2018年']
    

    输入文本为:

    此后,6月28日、7月9日和7月11日下午,武威市政协、市人大、市政府分别召开坚决全面彻底肃清火荣贵流毒和影响专题民主生活会。

    文本中提取的时间为:

    提取时间: ['此后', '6月28日', '7月9日', '7月11日下午']
    

    输入文本为:

    姜保红出生于1974年4月,她于2016年11月至2018年9月任武威市副市长,履新时,武威市的一把手正是火荣贵。

    文本中提取的时间为:

    提取时间: ['1974年4月', '2016年11月至2018年9月']
    

      本次分享到此结束,欢迎大家批评指正。

    注意:不妨了解下笔者的微信公众号: Python爬虫与算法(微信号为:easy_web_scrape), 欢迎大家关注~

    展开全文
  • Xponents是一组信息提取库,包括提取和规范化地理实体,日期/时间模式,关键字/分类法和各种模式。 例如,如图1所示: 图1.通用标记和编码范例。 文本 提取实体 归一化的名义输出 “博伊西,身份证很有趣!” ...
  • 3. 如果你想让某列按日期范围导出数据,就能按某列的日期范围导出数据; 4. 如果你想按某列的数值大小范围导出数据,就能按某列的数值范围导出数据; 5. 如果你想按某列文本前缀包含什么内容,就能按设定的前缀...

    1. 如果你想按某个分割符号去把长长的一整列数据拆分成多列;

    2. 如果你想导出拆分后数据,你希望勾选那一列就导出那一列数据,勾选多列就导出多列数据;

    3. 如果你想让某列按日期范围导出数据,就能按某列的日期范围导出数据;

    4. 如果你想按某列的数值大小范围导出数据,就能按某列的数值范围导出数据;

    5. 如果你想按某列文本前缀包含什么内容,就能按设定的前缀条件导出数据;

    6. 如果你想按某列文本后缀包含什么内容,就能按设定的后缀条件导出数据;

    7. 如果你想按某列文本前缀包含什么内容,后缀同时必须包含什么内容 ,就能按设定的前缀和后缀条件导出数据;

    8. 如果你想按某列文本前缀包含什么内容,中间偏后的部分包含什么内容 ,就能按设定的前缀和中间偏后的设定的条件导出数据;

    9.如果你想按某列文本后缀包含什么内容,中间偏前的部分包含什么内容 ,就能按设定的后缀和中间偏前的设定的条件导出数据;

    10. 如果你想按某列货币值的范围导出数据,就能按设定的货币范围导出数据;

    11. 如果你想按某列等于或者不等于什么内容导出数据,就能按照你希望结果导出数据;

    总结:我们可以每次导出一类数据,分多次导出,想想看,是不是就能实现从大数据里分类导出我想要的分类数据,

    以上描述的功能这款 “大数据 - 文本文件数据提取工具” 都能帮你轻松完成!如果你想现在立刻就拥有它,赶快来联系我吧,

    早一天拥有!你就早一天受益!请你先认真阅读一遍我的博客,看看是不是你一直在等待的大数据软件!

    范例1 根据设置列数据的时间范围提取(导出)数据

    支持的日期格式(包括时间格式)如下:

                "HH:mm",
                "HH:mm:ss",
                "yyyy/MM",
                "yyyy/MM/dd",
                "yyyy/MM/dd HH:mm",
                "yyyy/MM/dd HH:mm:ss",
                "yyyy-MM",
                "yyyy-MM-dd",
                "yyyy-MM-dd HH:mm",
                "yyyy-MM-dd HH:mm:ss",
                "yyyy.MM",
                "yyyy.MM.dd",
                "yyyy.MM.dd HH:mm",
                "yyyy.MM.dd HH:mm:ss",
                "yyyyMM",
                "yyyyMMdd",
                "yyyyMMddHHmm",
                "yyyyMMddHHmmss",
                "yyyy年MM月",
                "yyyy年MM月dd日",
                "yyyy年MM月dd日 HH时mm分",
                "yyyy年MM月dd日 HH时mm分ss秒"

     

    范例2   根据货币值范围导出文本数据(支持全世界各国货币汇率换算)

    范例3   根据百分比大小范围导出文本数据 

    范例4   根据字符串前缀和后缀导出文本数据  

     

    展开全文
  • 从文本文档和字符串中提取重要数据的工具Sammler从文本文档和字符串中提取重要数据的工具支持的数据类型电子邮件IP地址MAC地址日期和时间信用卡号码域电话号码用法将每个文件或字符串传递到使用-f /-file标志进行...
  • 从文本文档和字符串中提取重要数据的工具 支持的数据类型 电子信箱 IP地址 MAC地址 日期和时间 信用卡卡号 域 电话号码 用法 使用-f/--file标志传递每个文件或字符串以进行检查(可以多次使用) 使用-a/--all -all...
  •  (1)如何能构建一个系统,以至非结构化文本中提取结构化数据?  (2)有哪些稳健的方法识别一个文本描述的实体和关系?  (3)哪些语料库适合这项工作,如何使用它们来训练和评估模型? 一 信息提取 ...

    回答下列问题:

      (1)如何能构建一个系统,以至从非结构化文本中提取结构化数据?

      (2)有哪些稳健的方法识别一个文本描述的实体和关系?

      (3)哪些语料库适合这项工作,如何使用它们来训练和评估模型?

    一 信息提取

    信息有很多种”形状“和”大小“,一个重要的形式是结构化数据:实体和关系的规范和可预测的组织。例如:我们可能对公司和地点之间的关系,可用关系数据库存储。

    但如果我们尝试从文本中获得相似的信息,事情就比较麻烦了。如何从一段文字中发现一个实体和关系的表呢?

    然后,利用强大的查询工具,如SQL,这种从文本获取意义的方法被称为“信息提取

    信息提取有许多应用,包括商业智能、简历收获、媒体分析、情感检测、专利检索及电子邮件扫描。当前研究的一个特别重要的领域是提取出电子科学文献的结构化数据,特别是在生物学和医学领域。

    #信息提取结构


    要执行前面3个任务,句子分割器、分词器和词性标注器

    import nltk, re, pprint
    def ie_preprocess(document):
        sentences = nltk.sent_tokenize(document)                      #句子分割
        sentences = [nltk.word_tokenize(sent) for sent in sentences]  #分词
        sentences = [nltk.pos_tag(sent) for sent in sentence]         #词性标注器

    二 分块

    于实体识别的基本技术是分块(chunking)


    小框显示词级标识符和词性标注,同时,大框显示较高级的程序分块

    在本节上,我们将在较深的层面上探讨程序分块,以组块的定义和表示开始,我们将看到正则表达式和n-gram方法分块,使用CoNLL-2000分块语料库开发和评估分块器。

    #名词短语分块

    NP-chunking(名词短语分块),寻找单独名词短语对应的块

    NP-分块信息最有用的来源之一是词性标记。这是在信息提取系统中进行词性标注的动机之一。

    为了创建NP-分块,首先定义分块语法,规定句子应如何分块。在本例中,使用一个正则表达式规则定义一个简单的语法。

    这条规则是NP-分块有可选的且后面跟着任意数目形容词的限定词和名词组成。使用此语法,我们创建了组块分析器,测试我门的例句。结果得到树状图,可以输出或显示图形。

    sentence = [("the","DT"),("little","JJ"),("yellow","JJ"),("dog","NN"),("barked","VBD"),("at","IN"),("the","DT"),("cat","NN")]
    grammar = "NP: {<DT>?<JJ>*<NN>}"
    cp = nltk.RegexpParser(grammar)
    result = cp.parse(sentence)
    print result
    (S
      (NP the/DT little/JJ yellow/JJ dog/NN)
      barked/VBD
      at/IN
      (NP the/DT cat/NN))
    result.draw()

    #标记模式

    使用图形界面nltk.app.chunkparser()

    #用正则表达式分块

    grammer = r"""
       NP: {<DT|PP\$>?<JJ>*<NN>}    #匹配一个可选的限定词或所有格代名词
           {<NNP>+}                 #匹配一个或多个专有名词
    """
    cp = nltk.RegexpParser(grammer)
    sentence = [("Rapunzel","NNP"),("let","VBD"),("down", "RP"),("her","PP$"),("long","JJ"),("golden","JJ"),("hair","NN")]
    print cp.parse(sentence)
    (S
      (NP Rapunzel/NNP)
      let/VBD
      down/RP
      (NP her/PP$ long/JJ golden/JJ hair/NN))
    nouns = [("money","NN"),("market","NN"),("fund","NN")]
    grammar = "NP: {<NN><NN>}"  #如果将匹配两个连续名词的文本的规则应用到包含3个连续名词的文本中,则只有前两个名词被分块
    cp = nltk.RegexpParser(grammar)
    print cp.parse(nouns)
    (S (NP money/NN market/NN) fund/NN)

    #探索文本语料库

    使用分块器可以在已标注的语料库中提取匹配特定词性标记序列的短语

    cp = nltk.RegexpParser('CHUNK: {<V.*> <TO> <V.*>}')
    brown = nltk.corpus.brown
    for sent in brown.tagged_sents():
        tree = cp.parse(sent)
        for subtree in tree.subtrees():
            if subtree.label() == 'CHUNK': 
                print subtree
    (CHUNK combined/VBN to/TO achieve/VB)
    (CHUNK continue/VB to/TO place/VB)
    (CHUNK serve/VB to/TO protect/VB)
    (CHUNK wanted/VBD to/TO wait/VB)
    (CHUNK allowed/VBN to/TO place/VB)
    ......

    #缝隙

    为不包括在大块中的标识符序列定义一个缝隙

    加缝隙是从大块中去除标识符序列的过程

    grammar = r"""
    NP:
       {<.*>+}
       }<VBD|IN>+{"""
    sentence = [("the","DT"),("little","JJ"),("yellow","JJ"),("dog","NN"),("barked","VBD"),("at","IN"),("the","DT"),("cat","NN")]
    cp = nltk.RegexpParser(grammar)
    print cp.parse(sentence)
    (S
      (NP the/DT little/JJ yellow/JJ dog/NN)
      barked/VBD
      at/IN
      (NP the/DT cat/NN))

    #分块的表示:标记与树状图

    作为标注和分析之间的中间状态,块结构可以使用标记或树状图来表示。使用最广泛的表示是IOB标记

    在这个方案中,每个标识符被用3个特殊的块标签之一标注,I(inside,内部),O(outside,外部)或B(begin,开始)。

    B标志着它是分块的开始。块内的标识符子序列被标志为I,其他为O

    B和I标记是块类型的后缀,如B-NP, I-NP。

    NLTK用树状图作为分块的内部表示,却提供这些树状图与IOB之间格式转换的方法

    3 开发和评估分块器

    如何评估分块器

    #读取IOB格式与CoNLL2000分块语料库

    CoNLL2000分块语料库包含27万词的《华尔街日报文本》,分为“训练”和“测试”两部分,标注有词性标记和IOB格式分块标记。

    from nltk.corpus import conll2000
    print conll2000.chunked_sents('train.txt')[99]
    (S
      (PP Over/IN)
      (NP a/DT cup/NN)
      (PP of/IN)
      (NP coffee/NN)
      ,/,
      (NP Mr./NNP Stone/NNP)
      (VP told/VBD)
      (NP his/PRP$ story/NN)
      ./.)
    包含 3中分块类型:NP分块,VP分块,PP分块
    print conll2000.chunked_sents('train.txt', chunk_types=['NP'])[99]  #只选择NP分块

    #简单评估和基准

    cp = nltk.RegexpParser("")     #不分块
    test_sents = conll2000.chunked_sents('test.txt',chunk_types=['NP'])
    print cp.evaluate(test_sents)  #评估结果
    ChunkParse score:
        IOB Accuracy:  43.4%%
        Precision:      0.0%%
        Recall:         0.0%%
        F-Measure:      0.0%%
    grammar = r"NP: {<[CDJNP].*>+}"
    cp = nltk.RegexpParser(grammar)     #初级的正则表达式分块器
    test_sents = conll2000.chunked_sents('test.txt')
    print cp.evaluate(test_sents)  #评估结果
    ChunkParse score:
        IOB Accuracy:  62.5%%
        Precision:     70.6%%
        Recall:        38.5%%
        F-Measure:     49.8%%
    使用unigram标注器对名词短语分块

    #使用训练语料找到对每个词性标记最有可能的块标记(I、O或B)
    #可以用unigram标注器建立一个分块器,但不是要确定每个词的正确词性标记,而是给定每个词的词性标记,尝试确定正确的块标记
    class UnigramChunker(nltk.ChunkParserI):
        def __init__(self, train_sents):
            train_data = [[(t,c) for w,t,c in nltk.chunk.tree2conlltags(sent)] for sent in train_sents]
            self.tagger = nltk.UnigramTagger(train_data)
    
        def parse(self, sentence):
            pos_tags = [pos for (word,pos) in sentence]
            tagged_pos_tags = self.tagger.tag(pos_tags)
            chunktags = [chunktag for (pos, chunktag) in tagged_pos_tags]
            #为词性标注IOB块标记
            conlltags = [(word, pos, chunktag) for ((word,pos),chunktag) in zip(sentence, chunktags)]
            return nltk.chunk.conlltags2tree(conlltags) #转换成分块树状图
    #使用CoNLL2000分块语料库训练
    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)
    ChunkParse score:
        IOB Accuracy:  92.9%%
        Precision:     79.9%%
        Recall:        86.8%%
        F-Measure:     83.2%%

    
    
    postags = sorted(set(pos for sent in train_sents for (word,pos) in sent.leaves()))
    print unigram_chunker.tagger.tag(postags)
    [(u'#', u'B-NP'), (u'$', u'B-NP'), (u"''", u'O'), (u'(', u'O'), (u')', u'O'), (u',', u'O'), (u'.', u'O'), (u':', u'O'), (u'CC', u'O'), (u'CD', u'I-NP'), (u'DT', u'B-NP'), (u'EX', u'B-NP'), (u'FW', u'I-NP'), (u'IN', u'O'), (u'JJ', u'I-NP'), (u'JJR', u'B-NP'), (u'JJS', u'I-NP'), (u'MD', u'O'), (u'NN', u'I-NP'), (u'NNP', u'I-NP'), (u'NNPS', u'I-NP'), (u'NNS', u'I-NP'), (u'PDT', u'B-NP'), (u'POS', u'B-NP'), (u'PRP', u'B-NP'), (u'PRP$', u'B-NP'), (u'RB', u'O'), (u'RBR', u'O'), (u'RBS', u'B-NP'), (u'RP', u'O'), (u'SYM', u'O'), (u'TO', u'O'), (u'UH', u'O'), (u'VB', u'O'), (u'VBD', u'O'), (u'VBG', u'O'), (u'VBN', u'O'), (u'VBP', u'O'), (u'VBZ', u'O'), (u'WDT', u'B-NP'), (u'WP', u'B-NP'), (u'WP$', u'B-NP'), (u'WRB', u'O'), (u'``', u'O')]
    #使用训练语料找到对每个词性标记最有可能的块标记(I、O或B)
    #可以用bigram标注器建立一个分块器,但不是要确定每个词的正确词性标记,而是给定每个词的词性标记,尝试确定正确的块标记
    class BigramChunker(nltk.ChunkParserI):
        def __init__(self, train_sents):
            train_data = [[(t,c) for w,t,c in nltk.chunk.tree2conlltags(sent)] for sent in train_sents]
            self.tagger = nltk.BigramTagger(train_data)
    
        def parse(self, sentence):
            pos_tags = [pos for (word,pos) in sentence]
            tagged_pos_tags = self.tagger.tag(pos_tags)
            chunktags = [chunktag for (pos, chunktag) in tagged_pos_tags]
            #为词性标注IOB块标记
            conlltags = [(word, pos, chunktag) for ((word,pos),chunktag) in zip(sentence, chunktags)]
            return nltk.chunk.conlltags2tree(conlltags) #转换成分块树状图
    bigram_chunker = BigramChunker(train_sents)
    print bigram_chunker.evaluate(test_sents)
    ChunkParse score:
        IOB Accuracy:  93.3%%
        Precision:     82.3%%
        Recall:        86.8%%
        F-Measure:     84.5%%

    #训练基于分类器的分块器

    有时词性标记不足以确定一个句子应如何分块

    安装ocaml   

    安装maxnet     最大熵

    class ConsecutiveNPChunkTagger(nltk.TaggerI):
        def __init__(self, train_sents):
            train_set = []
            for tagged_sent in train_sents:
                untagged_sent = nltk.tag.untag(tagged_sent)
                history = []
                for i, (word,tag) in enumerate(tagged_sent):
                    featureset = npchunk_features(untagged_sent, i, history)
                    train_set.append( (featureset, tag) )
                    history.append(tag)
            self.classifier = nltk.MaxentClassifier.train(train_set, algorithm='megam', trace=0) #最大熵
        def tag(self, sentence):
            history = []
            for i, word in enumerate(sentence):
                featureset = npchunk_features(sentence, i, history)
                tag = self.classifier.classify(featureset)
                history.append(tag)
            return zip(sentence, history)
        
    class ConsecutiveNPChunker(nltk.ChunkParserI):
        def __init__(self, train_sents):
            tagged_sents = [[((w,t),c) for (w,t,c) in nltk.chunk.tree2conlltags(sent)] for sent in train_sents]
            self.tagger = ConsecutiveNPChunkTagger(tagged_sents)
        def parse(self, sentence):
            tagged_sents = self.tagger.tag(sentence)
            conlltags = [(w,t,c) for ((w,t),c) in tagged_sents]
            return nltk.chunk.conlltags2tree(conlltags)
    def npchunk_features(sentence, i, history):
        word, pos = sentence[i]    
        return {"pos": pos} #只提供当前标识符的词性标记

    chunker = ConsecutiveNPChunker(train_sents)
    print chunker.evaluate(test_sents)
    ChunkParse score:
        IOB Accuracy:  92.9%%
        Precision:     79.9%%
        Recall:        86.7%%
        F-Measure:     83.2%%

    def npchunk_features(sentence, i, history):
        word, pos = sentence[i]
        if i == 0: 
            prevword, prevpos = "<START>", "<START>"
        else:
            prevword, prevpos = sentence[i-1]  
       return {"pos": pos, "prevpos": prevpos} #模拟相邻标记之间的相互作用

    chunker = ConsecutiveNPChunker(train_sents)
    print chunker.evaluate(test_sents)
    ChunkParse score:
        IOB Accuracy:  93.7%%
        Precision:     82.1%%
        Recall:        87.2%%
        F-Measure:     84.5%%

    def npchunk_features(sentence, i, history):
        word, pos = sentence[i]
        if i == 0:
            prevword, prevpos = "<START>", "<START>"
        else:
            prevword, prevpos = sentence[i-1]
        return {"pos": pos, "word": word, "prevpos": prevpos}   #增加词的内容
    chunker = ConsecutiveNPChunker(train_sents)
    print chunker.evaluate(test_sents)
    ChunkParse score:
        IOB Accuracy:  94.2%%
        Precision:     83.2%%
        Recall:        88.3%%
        F-Measure:     85.7%%

    
    

    def npchunk_features(sentence, i, history):
        word, pos = sentence[i]
        if i == 0:
            prevword, prevpos = "<START>", "<START>"
        else:
            prevword, prevpos = sentence[i-1]
        if i == len(sentence)-1:
            nextword, nextpos = "<END>", "<END>"
        else:
            nextword, nextpos = sentence[i+1]
        return {"pos": pos,
                "word": word,
                "prevpos": prevpos,
                "nextpos": nextpos,
                "prevpos+pos": "%s+%s" % (prevpos, pos),
                "pos+nextpos": "%s+%s" % (pos, nextpos),
                "tags-since-dt": tags_since_dt(sentence, i)}  #预取特征、配对功能和复杂的语境特征
    def tags_since_dt(sentence, i):
        tags = set()
        for word, pos in sentence[:i]:
            if pos == "DT":
                tags = set()
            else:
                tags.add(pos)
        return '+'.join(sorted(tags))
    chunker = ConsecutiveNPChunker(train_sents)
    print chunker.evaluate(test_sents)
    ChunkParse score:
        IOB Accuracy:  96.0%%
        Precision:     88.8%%
        Recall:        91.1%%
        F-Measure:     89.9%%

    四 语言结构中的递归

    #用级联分块器构建嵌套结构

    只需创建一个包含递归规则的多级的分块语法,就可以建立任意深度的分块结构

    例子展示名词短语、介词短语、动词短语和句子的模式

    grammar = r"""
       NP: {<DT|JJ|NN.*>+}
       PP: {<IN><NP>}
       VP: {<VB.*><NP|PP|CLAUSE>+$}
       CLAUSE: {<NP><VP>}
    """
    cp = nltk.RegexpParser(grammar)
    sentence = [("Mary","NN"), ("saw","VBD"),("the","DT"),("cat","NN"),("sit","VB"),("on","IN"),("the","DT"),("mat","NN")]
    print cp.parse(sentence)
    (S
      (NP Mary/NN)
      saw/VBD   #无法识别VP
      (CLAUSE
        (NP the/DT cat/NN)
        (VP sit/VB (PP on/IN (NP the/DT mat/NN)))))
    cp = nltk.RegexpParser(grammar, loop=2)  #添加循环
    print cp.parse(sentence)
    (S
      (CLAUSE
        (NP Mary/NN)
        (VP
          saw/VBD
          (CLAUSE
            (NP the/DT cat/NN)
            (VP sit/VB (PP on/IN (NP the/DT mat/NN)))))))

    #树状图

    在NLTK中,创建树状图,方法是给节点添加标签和一个子链表

    #树遍历

    使用递归函数来遍历树是标准的做法

    五 命名实体识别


    命名实体识别(NER)系统的目标是识别所有文字提及的命名实体。这可以分解成两个子任务:确定NE的边界和确定其类型。命名实体识别经常是信息提取中关系识别的前奏,也有助于其他任务。例如:在问答系统(QA)中,我们试图提高信息检索的精确度,不用返回整个页面而只是包含用户问题的答案的那部分。大多数QA系统利用标准信息检索返回的文件,然后尝试分离文档中包含答案的最小的文本分段P303,例如问题:Who was the first President of the US?被检索的文档中包含答案,但我们想得到的答案应该是X was the first President of the US的形式,其中X不仅是一个名词短语也是一个PER类型的命名实体。
    如何识别命名实体呢?一种方法是查找适当的名称列表,但问题是许多实体措辞有歧义,如May和North可能是日期和地点

    因此我们需要能够识别多标识符序列的开头和结尾

    NER是一个非常适合用于分类器类型的方法。

    NLTK提供了一个已经训练好的可以识别命名实体的分类器,使用函数nltk.ne_chunk()访问。

    sent = nltk.corpus.treebank.tagged_sents()[22]
    print nltk.ne_chunk(sent, binary=True)    #如果设置参数binary=True,那么命名实体只被标注为NE
    (S
      The/DT
      (NE U.S./NNP)
      is/VBZ
      one/CD
      of/IN
    print nltk.ne_chunk(sent)    #PERSON, ORGANIZATION and GPE
    (S
      The/DT
      (GPE U.S./NNP)
      is/VBZ
      ......
      (PERSON Brooke/NNP T./NNP Mossman/NNP)
      ,/,
      a/DT
      professor/NN
      of/IN
      pathlogy/NN
      at/IN
      the/DT
      (ORGANIZATION University/NNP)
      of/IN
      (PERSON Vermont/NNP College/NNP)
      of/IN
      (GPE Medicine/NNP)

    六 关系抽取

    只要文本中的命名实体被识别,我们就可以提取它们之间存在的关系。

    方法之一是首先寻找所有(X, a, Y)形式的三元组,其中X和Y是指定类型的命名实体,a表示X和Y之间关系的字符串

    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.relextract.rtuple(rel)
    [ORG: u'WHYY'] u'in' [LOC: u'Philadelphia']
    [ORG: u'McGlashan & Sarrail'] u'firm in' [LOC: u'San Mateo']
    [ORG: u'Freedom Forum'] u'in' [LOC: u'Arlington']
    [ORG: u'Brookings Institution'] u', the research group in' [LOC: u'Washington']
    [ORG: u'Idealab'] u', a self-described business incubator based in' [LOC: u'Los Angeles']
    [ORG: u'Open Text'] u', based in' [LOC: u'Waterloo']

    七 深入阅读








































    展开全文
  • 在一个data文件夹存在多个指定格式的TXT文本文件,可以按照人员和数据的日期提取自己所需要的数据,更改源码可以实现不同格式的数据的提取。 注意事项: 1、开发环境为Visual Studio 2010,使用.net 2.0开发 ...
  • Hive身份证号中提取相关信息_性别_年龄_出生日期_详细地址 目录 一、居民身份证的简介 二、身份证的组成和结构 2-1、18位的居民身份证号: 2-2、15位的居民身份证号: 2-3、地址码 三、代码撸起来 3-1、...
  • 使用 Linux 文本工具简化数据的提取

    千次阅读 2006-10-02 01:03:00
    本文将逐一介绍这些数据提取工具及其操作,将它们应用到日常工作所使用的典型文件,并介绍一下为什么这些工具对于这些文件中提取数据来说非常重要。"; ...
  • 1. 我们如何能构建一个系统,非结构化文本中提取结构化数据?2. 有哪些稳健的方法识别一个文本中描述的实体和关系?3. 哪些语料库适合这项工作,我们如何使用它们来训练和评估我们的模型?7.1 信息提取#一个重要的...
  • Python日期实体提取

    千次阅读 2019-12-04 21:16:44
    用户的语音在发送给后台进行请求时已经转换成中文文本,然而由于语音转换工具的识别问题,许多日期类的数据并不是严格的数字,会出现诸如“六月12”“2016年八月”“20160812”“后天下午”等形式。 例如“我要今天...
  • 提取日期中的年月日及其他格式 提取年:datepart(yy,getdate()) 提取月:datepart(mm,getdate()) 提取日:datepart(dd,getdate()) 提取日期格式: Select CONVERT(varchar(100), GETDATE(), 0): 05 16 2006 10:57AM ...
  • jieba分词,连接数据库,分析数据库文本,并提取时间、地点、目标,整个完整流程/
  • 本文将详细讲解数据预处理、Jieba分词和文本聚类知识,这篇文章可以说是文本挖掘和自然语言处理的入门文章。两万字基础文章,希望对您有所帮助。欢迎大家来到“Python零到壹”,在这里我将分享约200篇Python系列...
  • 复制并粘贴文本字段的表格内容,然后输入要提取的列号,然后按开始 - 修剪线 - 行尾删除空格 - 替换文本 - 用另一个替换一个字符串 - 格式JSON - 漂亮格式的JSON字符串 - URLEncode - 将字符串编码为URL安全...
  • NLPIR文本分析工具的功能和特色介绍

    千次阅读 2019-11-05 15:39:52
    通常用于研究分析的数据,非结构化的数据所占比例更高,这些非结构化的数据也包含着重要的信息量,要运用文本分析工具来完成信息提取文本分析是自然语言处理的一个分支,是指从文本中抽取特征词进行量化以...
  • python文本分析工具 探索性数据分析是任何机器学习工作流程最重要的部分之一,自然语言处理也是如此。 但是,您应该选择哪种工具来有效地浏览和可视化文本数据? 在本文(Shahul Es最初在 Neptune博客 上发布 ...
  • 来源:Python大数据分析pdf是一种便携式文档格式,由Adobe公司设计。因为不受平台限制,且方便保存和传输,所以pdf非常受欢迎。目前市场上有很多pdf工具,大部分是阅读类,也有支持...
  • 程序功能: ...日期,开盘价,最高价,最低价,收盘价,成交金额,成交量 价格单位:元 成交金额单位:元 成交量单位:股 只要是通信达数据格式均可转换 已测试国泰君安,和招商软件,中信证券.  
  • 如何实现一款随机测试大数据生成工具(适用于任何排序算法测速) 哈希排序软件运行环境 支持操作系统:Windows 7/8/10 64位系统,64位Linux系统和64位苹果操作系统 运行内存:16GB Kingmax 1860GHz,通常...
  • 本软件提供了45大类共几百种针对txt文本文件的全文或者每一行的批量处理或者批量替换操作,是您经常性处理文本文件的得力工具。 功能大类列表如下(每一大类又分别包含多项子功能): 1.强大的针对文本文档全文...
  • 本软件提供了45大类共几百种针对txt文本文件的全文或者每一行的批量处理或者批量替换操作,是您经常性处理文本文件的得力工具。 功能大类列表如下(每一大类又分别包含多项子功能): 1.强大的针对文本文档全文内容...
  • 写文章,查论文或看文献的时候,面对许多图表,要引用别人的数据,或者想把自己的数据处理结果和别人的数据对比一下,可是怎么才能别人的论文或文献把数据提取出来了呢? 如果你有这方面的需求,那么你来对了地方.试试...
  • 小工具 API 使您的小工具可以远程提取其他网络服务器和网页的内容并对其进行操作。小工具 API 提供了 makeRequest(url, callback, opt_params) 函数以进行检索和操作远程网络内容。该函数将使用以下参数:String url...
  • 前文分享了疫情相关新闻数据爬取,并进行中文分词处理及文本聚类、LDA主题模型分析。这篇文章将抓取微博话题及评论信息,采用SnowNLP进行简单的情感分析及文本挖掘,包括随时间的情感分布。希望这篇基础性文章对您...
  • 中文文本信息抽取cocoNLP

    千次阅读 2020-03-25 09:00:00
    '],2,4) >>> # 抽取的关键词按照排序rank,高到低 >>> ranked_words = r.get_ranked_phrases() >>> # 抽取的关键词按照排序rank,带rank分高到低 >>> ranked_words_score = r.get_ranked_phrases_with_scores() >...
  • 文本处理方法概述

    千次阅读 2018-05-09 15:39:28
    转自:https://www.cnblogs.com/arachis/p/text_dig.html说明:本篇以实践为主,理论部分会尽量给出参考链接摘要:...文本挖掘(文本分类,文本标签化) 6.1 数据预处理 6.2 关于文本的特征工程 6.3 关于文本...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 31,410
精华内容 12,564
关键字:

从文本中提取日期小工具