精华内容
下载资源
问答
  • Stanford CoreNLP使用

    万次阅读 2018-08-22 20:56:17
    Stanford CoreNLP是斯坦福...安装过程我不再赘述,我主要写一下工具包的架构和基本使用。 1、Annotations和Annotators 这两种类是CoreNLP里面的基本架构。Annotations表示一类数据结构,CoreNLP的整个工具包里面...

    Stanford CoreNLP是斯坦福大学的自然语言处理工具包,目前已经支持多种语言的处理。该工具包需要java的支持,因此机器上需要安装java。目前最新的版本是3.9.1。安装过程我不再赘述,我主要写一下工具包的架构和基本使用。

    1、Annotations和Annotators
    这两种类是CoreNLP里面的基本架构。Annotations表示一类数据结构,CoreNLP的整个工具包里面输入和输出都是这种数据结构,因此我们自己的文本(一般是String类型)要传给CoreNLP使用,需要先转换成一种Annotations。Annotators是一类功能类,比如我们想分词或者断句等,这每一项功能对应一种annotator类,annotator类接受一种annotation作为输入,然后输出一种annotation。

    2、设置Annotators
    对一段文本,如果我们有多项功能需求,那么我们需要先设定使用哪几种annotators,设置的形式如下,

    // set up pipeline properties
    Properties props = new Properties();
    // set the list of annotators to run
    props.setProperty("annotators", "tokenize,ssplit,pos,lemma,ner,parse,depparse,coref,kbp,quote");
    

    可以看到,设定使用哪几种annotators的属性是通过properties来实现的。annotators的种类可以看这里,可以根据自己需要的处理任务设置所需的annotators。

    3、生成Annotations
    前面我们说过,annotations是CoreNLP数据传输的基本数据结构,因此我们需要将我们自己的文本转换为Annotation再进行处理,转换的方法很简单,

    // read some text in the text variable
    String text = "...";
    
    // create an empty Annotation just with the given text
    Annotation document = new Annotation(text);
    

    这里的Annotation类相当于一个基类,下面可以派生出许多不同annotator执行过后的生成的annotations。

    4、利用StanfordCoreNLP类进行处理
    属性设置好了,annotation也转换好了,现在就要用到StanfordCoreNLP这个类了。这个类是CoreNLP的接口类,所有参数都是传到这个类里面,执行也是通过这个类来完成,代码示例如下,

    StanfordCoreNLP pipeline = new StanfordCoreNLP(props);
    
    piepeline.annotate(document);

    StanfordCoreNLP类接受properties类的一个实例进行初始化,然后再接受一个annotation作为参数就可以进行处理了。把上面的代码整合一下就是如下过程,

    import edu.stanford.nlp.pipeline.*;
    import java.util.*;
    
    public class BasicPipelineExample {
    
        public static void main(String[] args) {
    
            // creates a StanfordCoreNLP object, with POS tagging, lemmatization, NER, parsing, and coreference resolution
            Properties props = new Properties();
            props.setProperty("annotators", "tokenize, ssplit, pos, lemma, ner, parse, dcoref");
            StanfordCoreNLP pipeline = new StanfordCoreNLP(props);
    
            // read some text in the text variable
            String text = "...";
    
            // create an empty Annotation just with the given text
            Annotation document = new Annotation(text);
    
            // run all Annotators on this text
            pipeline.annotate(document);
    
        }
    
    }

    可以看到使用CoreNLP还是比较简单的,StanfordCoreNLP作为接口,设置properties,生成annotation即可开始处理。处理完之后,我们如何提取执行完的结果呢?答案是运行完的结果都可以从document这个变量里面提取。

    5、提取结果
    我们知道,annotator运行后的结果是annotation类型的数据结构,这里运行后生成的Annotation类主要是两种类型:CoreMap和CoreLabel。CoreMap是一种Map类型的数据结构,即键值对的形式。在前面annotators的annotators的种类链接中,每一种annotator运行完后都会生成一种annotation,如下图所示
    这里写图片描述
    这个GENERATED ANNOTATIONS这一栏所对应的类即是CoreMap中的key的类型,因此我们要提取结果就好办了,只需要确定对应annotator所生成的annotation的种类即可,以ssplit这个annotator为例,

    // these are all the sentences in this document
    // a CoreMap is essentially a Map that uses class objects as keys and has values with custom types
    List<CoreMap> sentences = document.get(SentencesAnnotation.class);
    
    for(CoreMap sentence: sentences) {
      // traversing the words in the current sentence
      // a CoreLabel is a CoreMap with additional token-specific methods
      for (CoreLabel token: sentence.get(TokensAnnotation.class)) {
        // this is the text of the token
        String word = token.get(TextAnnotation.class);
        // this is the POS tag of the token
        String pos = token.get(PartOfSpeechAnnotation.class);
        // this is the NER label of the token
        String ne = token.get(NamedEntityTagAnnotation.class);
      }
    
      // this is the parse tree of the current sentence
      Tree tree = sentence.get(TreeAnnotation.class);
    
      // this is the Stanford dependency graph of the current sentence
      SemanticGraph dependencies = sentence.get(CollapsedCCProcessedDependenciesAnnotation.class);
    }
    
    // This is the coreference link graph
    // Each chain stores a set of mentions that link to each other,
    // along with a method for getting the most representative mention
    // Both sentence and token offsets start at 1!
    Map<Integer, CorefChain> graph = 
      document.get(CorefChainAnnotation.class);

    这个SentencesAnnotation.class就是ssplit(断句)这个annotator所生成的annotation类,因此只要把这个参数传进去即可获取到ssplit运行的结果。CoreLabel也是一种特殊的CoreMap,只是有一些针对token的特殊方法(比如直接转换为String类型),本质上也是一种Map结构。从一个CoreMap我们可以生成语法树或者什么依存句法什么的,上面代码中的Tree就是语法树,SemanticGraph就是依存句法,可以直接打印出来,

    for(CoreMap sentence: sentences) {
       // traversing the words in the current sentence
       // this is the parse tree of the current sentence
    
       Tree tree = sentence.get(TreeCoreAnnotations.TreeAnnotation.class);
    
       System.out.println("语法树:");
    
       System.out.println(tree.toString());
    
    
    
       // this is the Stanford dependency graph of the current sentence
    
       SemanticGraph dependencies = sentence.get(SemanticGraphCoreAnnotations.CollapsedCCProcessedDependenciesAnnotation.class);
    
       System.out.println("依存句法:");
    
       System.out.println(dependencies.toString());
    }

    有些annotator的实现需要另一些annotator,因此在确定properties的annotator属性时要确定好所依赖的annotator都被添加进去,各个annotator的依赖关系看这里
    上面的几个过程是对英文的完整处理过程,除此之外CoreNLP还提供了一个更简单的API调用方法,不过简单方法虽然更直观,但灵活性不太好,因此这里不介绍了,如果需要可以看这个链接Simple API

    6、针对中文的处理
    上面的过程主要是针对英文,其实处理中文的方法也一样。处理中文需要一个额外的包,下载地址为(http://nlp.stanford.edu/software/stanford-chinese-corenlp-2018-02-27-models.jar),把这个包和CoreNLP的包放到一起添加到工程中即可。

    处理中文的代码也是一样的,只是在设置annotators这个属性时,一般使用的是默认的属性,这个配置是放在中文jar包下面的StanfordCoreNLP-chinese.properties文件里面

    # Pipeline options - lemma is no-op for Chinese but currently needed because coref demands it (bad old requirements system)
    annotators = tokenize, ssplit, pos, lemma, ner, parse, coref
    
    # segment
    tokenize.language = zh
    segment.model = edu/stanford/nlp/models/segmenter/chinese/ctb.gz
    segment.sighanCorporaDict = edu/stanford/nlp/models/segmenter/chinese
    segment.serDictionary = edu/stanford/nlp/models/segmenter/chinese/dict-chris6.ser.gz
    segment.sighanPostProcessing = true
    
    # sentence split
    ssplit.boundaryTokenRegex = [.。]|[!?!?]+
    
    # pos
    pos.model = edu/stanford/nlp/models/pos-tagger/chinese-distsim/chinese-distsim.tagger
    
    # ner
    ner.language = chinese
    ner.model = edu/stanford/nlp/models/ner/chinese.misc.distsim.crf.ser.gz
    ner.applyNumericClassifiers = true
    ner.useSUTime = false
    
    # regexner
    ner.fine.regexner.mapping = edu/stanford/nlp/models/kbp/chinese/cn_regexner_mapping.tab
    ner.fine.regexner.noDefaultOverwriteLabels = CITY,COUNTRY,STATE_OR_PROVINCE
    
    # parse
    parse.model = edu/stanford/nlp/models/srparser/chineseSR.ser.gz
    
    # depparse
    depparse.model    = edu/stanford/nlp/models/parser/nndep/UD_Chinese.gz
    depparse.language = chinese
    
    # coref
    coref.sieves = ChineseHeadMatch, ExactStringMatch, PreciseConstructs, StrictHeadMatch1, StrictHeadMatch2, StrictHeadMatch3, StrictHeadMatch4, PronounMatch
    coref.input.type = raw
    coref.postprocessing = true
    coref.calculateFeatureImportance = false
    coref.useConstituencyTree = true
    coref.useSemantics = false
    coref.algorithm = hybrid
    coref.path.word2vec =
    coref.language = zh
    coref.defaultPronounAgreement = true
    coref.zh.dict = edu/stanford/nlp/models/dcoref/zh-attributes.txt.gz
    coref.print.md.log = false
    coref.md.type = RULE
    coref.md.liberalChineseMD = false
    
    # kbp
    kbp.semgrex = edu/stanford/nlp/models/kbp/chinese/semgrex
    kbp.tokensregex = edu/stanford/nlp/models/kbp/chinese/tokensregex
    kbp.language = zh
    kbp.model = none
    
    # entitylink
    entitylink.wikidict = edu/stanford/nlp/models/kbp/chinese/wikidict_chinese.tsv.gz
    

    通常使用这个默认配置就可以了,使用方法如下,

    public class nlp_Chinese_demo {
        public static void main(String[] args) {
            String props="StanfordCoreNLP-chinese.properties";
            StanfordCoreNLP pipeline = new StanfordCoreNLP(props);
            Annotation document;
            //从文件中导入文本
            //document = new Annotation(IOUtils.slurpFileNoExceptions(file));
            annotation = new Annotation("欢迎使用使用斯坦福大学自然语言处理工具包!");
    
    
            pipeline.annotate(document);
            pipeline.prettyPrint(document, System.out);
        }
    }

    7、写在最后
    由于本人刚刚接触自然语言处理,因此很多概念还没有理解清楚,如果有什么不对的地方欢迎指正,谢谢!

    参考:https://stanfordnlp.github.io/CoreNLP/api.html

    展开全文
  • Stanford CoreNLP使用笔记

    2019-12-03 12:04:22
    前言:之前使用的时候,这个工具都是拿来直接用的,因为占用内存达到4g,通过购买硬件方式解决了内存占用过大的问题。...Stanford CoreNLP使用: Annotations和Annotators 这两种类是CoreNLP里面的基本架构。...

    前言:之前使用的时候,这个工具都是拿来直接用的,因为占用内存达到4g,通过购买硬件方式解决了内存占用过大的问题。现在想把这个工具接口给开放出来,所以必须放到服务器上去,4g的内存占用显然是不可能的。研究了下,发现去除一些自己用不到的功能可以大大降低内存,提高使用效率。

    Stanford CoreNLP的使用:

    1. Annotations和Annotators
      这两种类是CoreNLP里面的基本架构。Annotations表示一类数据结构,CoreNLP的整个工具包里面输入和输出都是这种数据结构,因此我们自己的文本(一般是String类型)要传给CoreNLP使用,需要先转换成一种Annotations。Annotators是一类功能类,比如我们想分词或者断句等,这每一项功能对应一种annotator类,annotator类接受一种annotation作为输入,然后输出一种annotation。
    2. 选择annotators -->确定你需要使用的功能(只选择你需要使用的功能, 不然会严重影响你的性能:启动时间、占用内存等),我这里将其做成bean注入的方式:
    	@Bean
        public StanfordCoreNLP getStanfordCoreNLP() {
            Properties props = new Properties();
            // props.setProperty("annotators", "tokenize, ssplit, pos, lemma, ner, parse, dcoref");
            // 只选择你需要使用的功能,原来没研究的时候,有ner、parse、dcoref;启动需要30s、内存占用4g左右
            // 现在启动3s、内存占用300m左右
            props.setProperty("annotators", "tokenize, ssplit, pos, lemma");
            StanfordCoreNLP pipeline = new StanfordCoreNLP(props);
            return pipeline;
        }
    
    1. text文本处理流程:
     @Autowired
        private StanfordCoreNLP pipeline;
    
        public List<String> getWordsByStanford(String sentenceStr) {
            // creates a StanfordCoreNLP object, with POS tagging, lemmatization,
            // NER, parsing, and coreference resolution
            // 这里将annotators的选择,以及StanfordCoreNLP类的生成,放在初始化项目时完成,并将StanfordCoreNLP类交给spring管理
            /*Properties props = new Properties();
            props.setProperty("annotators", "tokenize, ssplit, pos, lemma, ner, parse, dcoref");
            StanfordCoreNLP pipeline = new StanfordCoreNLP(props);*/
            List<String> wordPos = new ArrayList<>();
            // read some text in the text variable
    //            String text = "";// Add your text here!
            // create an empty Annotation just with the given text
            // 生成Annotations,annotations是CoreNLP数据传输的基本数据结构,因此我们需要将我们自己的文本转换为Annotation再进行处理
            Annotation document = new Annotation(sentenceStr);
    
            // run all Annotators on this text
            // 利用StanfordCoreNLP类进行处理
            pipeline.annotate(document);
    
            // these are all the sentences in this document
            // a CoreMap is essentially a Map that uses class objects as keys and
            // has values with custom types
            // 结果提取
            List<CoreMap> sentences = document.get(CoreAnnotations.SentencesAnnotation.class);
    
            for (CoreMap sentence : sentences) {
                // traversing the words in the current sentence
                // a CoreLabel is a CoreMap with additional token-specific methods
                for (CoreLabel token : sentence.get(CoreAnnotations.TokensAnnotation.class)) {
                    // this is the text of the token
                    String word = token.get(CoreAnnotations.TextAnnotation.class);
    
                    // this is the POS tag of the token
                    String pos = token.get(CoreAnnotations.PartOfSpeechAnnotation.class);
                    wordPos.add(word + "/" + pos);
                }
            }
            return wordPos;
        }
    
    1. 结果提取:annotator运行后的结果是annotation类型的数据结构,这里运行后生成的Annotation类主要是两种类型:CoreMap和CoreLabel。CoreMap是一种Map类型的数据结构,即键值对的形式。在前面annotators的annotators的种类链接中,每一种annotator运行完后都会生成一种annotation,如下图所示
      在这里插入图片描述

    2. dd

    展开全文
  • Standford CoreNLP使用

    2017-08-21 10:41:00
    1、官网https://stanfordnlp.github.io/CoreNLP/ 2、 待续... 转载于:https://www.cnblogs.com/freedommovie/p/7403072.html

    1、官网https://stanfordnlp.github.io/CoreNLP/

    2、

    待续...

    转载于:https://www.cnblogs.com/freedommovie/p/7403072.html

    展开全文
  • Stanford CoreNLP 使用Python调用时无法连接(psutil._exceptions.AccessDenied: psutil.AccessDenied) 环境 macOS Big Sur,python=3.6,jupyter notebook psutil._exceptions.AccessDenied: psutil.AccessDenied ...

    环境

    macOS Big Sur,python=3.6,jupyter notebook

    psutil._exceptions.AccessDenied: psutil.AccessDenied

    首先碰到了这个问题,之后找到github上的项目,在issues中有人提出了一些(可能)可行的解决方案
    github项目issues地址
    主要有两种选择,第一种是使用sudo + .py的方式来使用stanfordcorenlp,但考虑到我是在jupyter notebook中进行编程的,使用这个编辑器的初衷也是为了便于调试,如果使用sudo + .py的方式便无法调试程序;第二种是另一个人提出的,针对macOS+jupyter notebook环境的,如下图所示:
    在这里插入图片描述

    即修改corenlp.py中的这部分代码,将程序中帮助用户选择端口的部分注释掉,手动设置端口(self.port = 9999)
    我按照这个方法进行实验,虽然它不会再爆出AccessDenied的错误,但又出现了其他的问题

    在init StanfordCoreNLP时卡住

    具体表现在Jupyter Notebook中为Cell一直在运行,不会停止,也不会有任何输出,于是只能强行中断,然后在输出的错误信息中回到corenlp.py的源码中,找到了罪魁祸首:
    在这里插入图片描述

    可以看到这里有一个while循环,用于等待后端server的启动,如果server一直无法启动,那么程序便会一直在这个while循环中,无法退出,造成了我们前面看到的Cell一直运行不停止的现象。
    这个时候走投无路的我只能再去github项目下的issues中乱逛(碰运气),然后有人提到使用较低版本的stanfordcorenlp可以解决这个报错,于是我重新安装了低版本的库,果然最前面提到的那个报错不再出现,取而代之的是:
    ConnectionError: (‘Connection aborted.’, BadStatusLine(
    大致这样的一条报错,根据给出的报错信息,可以发现也是由于将请求发给server时出现了问题,一切的线索都指向:没有能够成功启动server

    最终解决方案

    没有办法,只能再再再去看github上的项目文档,发现里面还提到了一种使用方法,单独使用java启动stanfordcorenlp server,然后在init StanfordCoreNLP时指定url,之后就可以使用服务了。
    于是我想,既然使用corenlp.py脚本中的代码无法启动server,那么我先手动启动好是否可行呢,然后进行了实验:
    在这里插入图片描述

    这里出现了报错:“Unsupported major.minor version 52.0”,网上查了一下,大意是运行jar包需要jdk8,于是我切换了系统的jdk版本,这下可以了:
    在这里插入图片描述

    然后再将0:0:0:0:0:0:0:0这个地址放到stanfordcorenlp中进行init,发现它无法识别这个地址,查了一下corenlp.py中的代码,里面是通过地址头是否存在http来判断是否是地址,于是换成:
    在这里插入图片描述

    这样一来,就可以了:
    在这里插入图片描述

    最后再附上stanfordcorenlp的GitHub地址:
    stanfordcorenlp项目地址

    展开全文
  • 1、Stanford CoreNLP maven依赖,jdk依赖1.8 <dependency> <groupId>edu.stanford.nlp</groupId> <artifactId>stanford-corenlp</artifactId> <version>3.6.0</ver...
  • "http://127.0.0.1:9000" # 使用本机端口需要先在stanford目录下运行java,见stanford nlp官网 params = {"properties": '{"annotators": "tokenize"}', "pipelineLanguage": "zh"} text = "如今,若问城市里的男性...
  • coreNLP使用

    千次阅读 2016-05-06 20:44:10
    coreNLP是斯坦福大学开发的一套关于自然语言处理的工具(toolbox),使用简单功能强大,有;命名实体识别、词性标注、词语词干化、语句语法树的构造还有指代关系等功能,使用起来比较方便。 coreNLP使用Java编写的...
  • jave使用corenlp

    2021-07-13 11:31:02
    corenlp斯坦福大学开发的基于java语言的自然语言处理工具,能够为文本多种语言学标注,包括分词,句子边界,词性标注,命名实体识别,数字与时间,句法解析(dependency...使用流程: (1)从官网下载并解压 CoreNLP 4.
  • python-stanford-corenlp使用双向服务器-客户端接口的CoreNLP的Python接口
  • Python中使用Stanford CoreNLP

    万次阅读 多人点赞 2018-05-25 14:25:06
    Stanford CoreNLP的源代码是使用Java写的,提供了Server方式进行交互。stanfordcorenlp是一个对Stanford CoreNLP进行了封装的Python工具包,GitHub地址,使用非常方便。 安装依赖 1:下载安装JDK 1.8及以上版本。 ...
  • Stanford CoreNLP 3.6.0 使用入门

    万次阅读 2016-09-14 15:45:04
    Stanford CoreNLP由Java语言开发,是斯坦福...项目地址:GitHub本文主要记录使用注意事项。Stage 1首先我们要下载 CoreNLP Java包。 然后在Eclipse里面的Classpath里面引入jar文件。如下图红色框所示: CoreNLP只需
  • stanford coreNLP简单使用

    2021-04-26 22:36:47
    树结构可视化:安装nltk第三方包 from stanfordcorenlp import StanfordCoreNLP nlp = StanfordCoreNLP(r'C:/Users/bydlearner/PycharmProjects/pythonProject3/stanford-corenlp-4.2.0') # 这里改成你stanford-...
  • 本文记录入门使用CoreNLP-4.2.0中遇到的坑(因为官网文档落后,且默认针对ubuntu中分析英文,加上网上中文教程多针对3.9.0。而4.2.0有部分改动) 参考: CoreNLP官网 CoreNLP中文使用(3.9.0) 1.环境 Jdk8:版本低...
  • corenlp多线程使用

    2017-12-02 16:08:16
    本文的应用是stanford corenlp多线程的使用,在对数据进行分词、词性标注和命名实体识别的过程数据量较大,处理时间较长,单线程已经不能满足需求。这个使用场景是,读取文本,每一行是一个json类型的字符串,需要将...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,124
精华内容 849
关键字:

corenlp使用