OpenNLP - 快速指南

---

OpenNLP - 概述

NLP 是一组工具，用于从网页和文本文档等自然语言源中获取有意义且有用的信息。

什么是开放 NLP？

Apache OpenNLP是一个开源 Java 库，用于处理自然语言文本。您可以使用此库构建高效的文本处理服务。

OpenNLP 提供分词、句子切分、词性标注、命名实体提取、分块、解析和共指解析等服务。

OpenNLP 的特点

以下是 OpenNLP 的显着特征 -

• 命名实体识别 (NER) - Open NLP 支持 NER，使用它您甚至可以在处理查询时提取位置、人和事物的名称。

• 总结- 使用总结功能，您可以总结 NLP 中的段落、文章、文档或其集合。

• 搜索- 在 OpenNLP 中，即使给定的单词被更改或拼写错误，也可以在给定的文本中识别给定的搜索字符串或其同义词。

• 标记 (POS) - NLP 中的标记用于将文本划分为各种语法元素以进行进一步分析。

• 翻译- 在 NLP 中，翻译有助于将一种语言翻译成另一种语言。

• 信息分组- NLP 中的此选项对文档内容中的文本信息进行分组，就像词性一样。

• 自然语言生成- 用于从数据库生成信息并自动化信息报告，例如天气分析或医疗报告。

• 反馈分析- 顾名思义，NLP 收集人们对产品的各种类型的反馈，以分析产品如何成功赢得他们的心。

• 语音识别- 尽管分析人类语音很困难，但 NLP 具有一些满足此要求的内置功能。

开放 NLP API

Apache OpenNLP 库提供了类和接口来执行自然语言处理的各种任务，例如句子检测、标记化、查找名称、标记词性、对句子进行分块、解析、共同引用解析和文档分类。

除了这些任务之外，我们还可以针对任何这些任务训练和评估我们自己的模型。

OpenNLP CLI

除了库之外，OpenNLP 还提供了命令行界面（CLI），我们可以在其中训练和评估模型。我们将在本教程的最后一章详细讨论这个主题。

开放 NLP 模型

为了执行各种 NLP 任务，OpenNLP 提供了一组预定义的模型。该集合包括不同语言的模型。

下载模型

您可以按照以下步骤下载OpenNLP提供的预定义模型。

步骤 1 - 单击以下链接打开 OpenNLP 模型的索引页面 - http://opennlp.sourceforge.net/models-1.5/。

步骤 2 - 访问给定的链接时，您将看到各种语言的组件列表以及下载它们的链接。在这里，您可以获得OpenNLP提供的所有预定义模型的列表。

通过单击各自的链接将所有这些模型下载到文件夹C:/OpenNLP_models/> 。所有这些模型都依赖于语言，在使用这些模型时，您必须确保模型语言与输入文本的语言匹配。

OpenNLP 的历史

• 2010年，OpenNLP进入Apache孵化。

• 2011年，Apache OpenNLP 1.5.2 Incubating发布，同年毕业成为Apache顶级项目。

• 2015年，OpenNLP发布1.6.0。

OpenNLP - 环境

在本章中，我们将讨论如何在系统中设置 OpenNLP 环境。让我们从安装过程开始。

安装 OpenNLP

以下是在系统中下载Apache OpenNLP 库的步骤。

步骤 1 -单击以下链接打开Apache OpenNLP的主页- https://opennlp.apache.org/。

步骤 2 - 现在，单击“下载”链接。单击后，您将被定向到一个页面，您可以在其中找到各种镜像，这些镜像会将您重定向到 Apache Software Foundation Distribution 目录。

步骤 3 - 在此页面中，您可以找到下载各种 Apache 发行版的链接。浏览它们并找到 OpenNLP 发行版并单击它。

步骤 4 - 单击后，您将被重定向到可以看到 OpenNLP 发行版索引的目录，如下所示。

单击可用发行版中的最新版本。

步骤 5 - 每个发行版都提供各种格式的 OpenNLP 库的源文件和二进制文件。下载源文件和二进制文件apache-opennlp-1.6.0-bin.zip和apache-opennlp1.6.0-src.zip（适用于 Windows）。

设置类路径

下载OpenNLP库后，需要将其路径设置为bin目录。假设您已将OpenNLP库下载到系统的E盘。

现在，请按照下面给出的步骤操作 -

步骤 1 - 右键单击​​“我的电脑”并选择“属性”。

步骤 2 - 单击“高级”选项卡下的“环境变量”按钮。

步骤 3 - 选择路径变量并单击编辑按钮，如以下屏幕截图所示。

步骤 4 - 在编辑环境变量窗口中，单击新建按钮并添加 OpenNLP 目录E:\apache-opennlp-1.6.0\bin的路径，然后单击确定按钮，如以下屏幕截图所示。

Eclipse 安装

您可以通过设置 JAR 文件的构建路径或使用pom.xml来设置 OpenNLP 库的 Eclipse 环境。

设置 JAR 文件的构建路径

按照下面给出的步骤在 Eclipse 中安装 OpenNLP -

步骤 1 - 确保您的系统中安装了 Eclipse 环境。

步骤 2 - 打开 Eclipse。点击文件→新建→打开一个新项目，如下图。

步骤 3 - 您将获得新建项目向导。在此向导中，选择 Java 项目并单击“下一步”按钮继续。

步骤 4 - 接下来，您将获得新建 Java 项目向导。这里，需要新建一个项目，点击Next按钮，如下图。

步骤 5 - 创建新项目后，右键单击它，选择构建路径，然后单击配置构建路径。

步骤 6 - 接下来，您将获得Java 构建路径向导。在这里，单击“添加外部 JAR”按钮，如下所示。

步骤 7 - 选择位于apache-opennlp-1.6.0 文件夹的lib文件夹中的jar 文件opennlp-tools-1.6.0.jar和opennlp-uima-1.6.0.jar。

单击上面屏幕中的“打开”按钮后，所选文件将添加到您的库中。

单击“确定”后，您将成功将所需的 JAR 文件添加到当前项目，并且可以通过展开引用的库来验证这些添加的库，如下所示。

使用 pom.xml

将项目转换为 Maven 项目，并将以下代码添加到其pom.xml中。

<project xmlns="http://maven.apache.org/POM/4.0.0" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
http://maven.apache.org/xsd/maven-4.0.0.xsd"> 
   <modelVersion>4.0.0</modelVersion> 
   <groupId>myproject</groupId> 
   <artifactId>myproject</artifactId> 
   <version>0.0.1-SNAPSHOT</version> 
   <build> 
      <sourceDirectory>src</sourceDirectory> 
      <plugins> 
         <plugin> 
            <artifactId>maven-compiler-plugin</artifactId> 
            <version>3.5.1</version> 
            <configuration> 
               <source>1.8</source> 
               <target>1.8</target> 
            </configuration> 
         </plugin> 
      </plugins> 
   </build> 
   <dependencies>  
      <dependency> 
         <groupId>org.apache.opennlp</groupId> 
         <artifactId>opennlp-tools</artifactId> 
         <version>1.6.0</version> 
     </dependency> 
     <dependency> 
         <groupId>org.apache.opennlp</groupId> 
         <artifactId>opennlp-uima</artifactId> 
         <version>1.6.0</version> 
      </dependency>      
  </dependencies>  
</project> 

OpenNLP - 参考 API

在本章中，我们将讨论本教程后续章节中将使用的类和方法。

句子检测

句子模型类

此类表示用于检测给定原始文本中的句子的预定义模型。此类属于opennlp.tools.sentdetect包。

此类的构造函数接受句子检测器模型文件 (en-sent.bin) 的InputStream对象。

SentenceDetectorME 类

该类属于opennlp.tools.sentDetect包，它包含将原始文本拆分为句子的方法。此类使用最大熵模型来评估字符串中的句子结尾字符，以确定它们是否表示句子的结尾。

以下是该类的重要方法。

代币化

Tokenizer模型类

此类表示用于标记给定句子的预定义模型。该类属于包opennlp.tools.tokenizer。

此类的构造函数接受分词器模型文件 (entoken.bin) 的InputStream对象。

课程

为了执行标记化，OpenNLP 库提供了三个主要类。所有三个类都实现了名为Tokenizer的接口。

这些类包含以下方法。

除了上述两个方法外，TokenizerME类还有getTokenProbabilities()方法。

名称实体识别

TokenNameFinderModel 类

此类表示用于查找给定句子中的命名实体的预定义模型。这个类属于包opennlp.tools.namefind。

此类的构造函数接受名称查找器模型文件 (enner-person.bin) 的InputStream对象。

NameFinderME 类

该类属于opennlp.tools.namefind包，它包含执行 NER 任务的方法。此类使用最大熵模型来查找给定原始文本中的命名实体。

寻找词性

POS模型类

此类表示用于标记给定句子的词性的预定义模型。这个类属于包opennlp.tools.postag。

此类的构造函数接受pos-tagger 模型文件 (enpos-maxent.bin) 的InputStream对象。

POSTaggerME 类

该类属于opennlp.tools.postag包，用于预测给定原始文本的词性。它使用最大熵来做出决定。

解析句子

解析器模型类

此类表示用于解析给定句子的预定义模型。这个类属于包opennlp.tools.parser。

此类的构造函数接受解析器模型文件 (en-parserchunking.bin) 的InputStream对象。

解析器工厂类

该类属于opennlp.tools.parser包，用于创建解析器。

解析器工具类

该类属于opennlp.tools.cmdline.parser包，用于解析内容。

分块

Chunker模型类

此类表示用于将句子分成更小的块的预定义模型。这个类属于包opennlp.tools.chunker。

此类的构造函数接受chunker模型文件 (enchunker.bin)的InputStream对象。

ChunkerME 类

这个类属于名为opennlp.tools.chunker的包，它用于将给定的句子分成更小的块。

OpenNLP - 句子检测

在处理自然语言时，确定句子的开头和结尾是需要解决的问题之一。此过程称为句子边界消歧(SBD) 或简称为断句。

我们用来检测给定文本中的句子的技术取决于文本的语言。

使用 Java 进行句子检测

我们可以使用正则表达式和一组简单的规则来检测 Java 中给定文本中的句子。

例如，假设给定文本中的句子以句点、问号或感叹号结尾，那么我们可以使用String类的split()方法分割句子。在这里，我们必须传递字符串格式的正则表达式。

以下是使用 Java 正则表达式（分割方法）确定给定文本中的句子的程序。将此程序保存在名为SentenceDetection_RE.java的文件中。

public class SentenceDetection_RE {  
   public static void main(String args[]){ 
     
      String sentence = " Hi. How are you? Welcome to Tutorialspoint. " 
         + "We provide free tutorials on various technologies"; 
     
      String simple = "[.?!]";      
      String[] splitString = (sentence.split(simple));     
      for (String string : splitString)   
         System.out.println(string);      
   } 
}

使用以下命令从命令提示符编译并执行保存的 java 文件。

javac SentenceDetection_RE.java 
java SentenceDetection_RE

执行时，上述程序会创建一个 PDF 文档，显示以下消息。

Hi 
How are you 
Welcome to Tutorialspoint 
We provide free tutorials on various technologies

使用 OpenNLP 进行句子检测

为了检测句子，OpenNLP 使用预定义的模型，即名为en-sent.bin 的文件。该预定义模型经过训练可以检测给定原始文本中的句子。

opennlp.tools.sentdetect包包含用于执行句子检测任务的类和接口。

要使用 OpenNLP 库检测句子，您需要 -

• 使用SentenceModel类加载en-sent.bin模型

• 实例化SentenceDetectorME类。

• 使用此类的sentDetect()方法检测句子。

以下是编写一个从给定原始文本中检测句子的程序所需遵循的步骤。

第 1 步：加载模型

句子检测模型由名为SentenceModel的类表示，该类属于opennlp.tools.sentDetect包。

加载句子检测模型 -

• 创建模型的InputStream对象（实例化FileInputStream并将模型的路径以字符串格式传递给其构造函数）。

• 实例化SentenceModel类并将模型的InputStream （对象）作为参数传递给其构造函数，如以下代码块所示 -

//Loading sentence detector model 
InputStream inputStream = new FileInputStream("C:/OpenNLP_models/ensent.bin"); 
SentenceModel model = new SentenceModel(inputStream);

步骤 2：实例化 SentenceDetectorME 类

opennlp.tools.sentDetect包的 SentenceDetectorME 类包含将原始文本拆分为句子的方法。此类使用最大熵模型来评估字符串中的句尾字符，以确定它们是否表示句子的结尾。

实例化该类并传递上一步中创建的模型对象，如下所示。

//Instantiating the SentenceDetectorME class 
SentenceDetectorME detector = new SentenceDetectorME(model);

第三步：检测句子

SentenceDetectorME类的sentDetect ()方法用于检测传递给它的原始文本中的句子。该方法接受一个字符串变量作为参数。

通过将句子的字符串格式传递给此方法来调用此方法。

//Detecting the sentence 
String sentences[] = detector.sentDetect(sentence);

例子

以下是检测给定原始文本中的句子的程序。将此程序保存在名为SentenceDetectionME.java的文件中。

import java.io.FileInputStream; 
import java.io.InputStream;  

import opennlp.tools.sentdetect.SentenceDetectorME; 
import opennlp.tools.sentdetect.SentenceModel;  

public class SentenceDetectionME { 
  
   public static void main(String args[]) throws Exception { 
   
      String sentence = "Hi. How are you? Welcome to Tutorialspoint. " 
         + "We provide free tutorials on various technologies"; 
       
      //Loading sentence detector model 
      InputStream inputStream = new FileInputStream("C:/OpenNLP_models/en-sent.bin"); 
      SentenceModel model = new SentenceModel(inputStream); 
       
      //Instantiating the SentenceDetectorME class 
      SentenceDetectorME detector = new SentenceDetectorME(model);  
    
      //Detecting the sentence
      String sentences[] = detector.sentDetect(sentence); 
    
      //Printing the sentences 
      for(String sent : sentences)        
         System.out.println(sent);  
   } 
}

使用以下命令从命令提示符编译并执行保存的 Java 文件 -

javac SentenceDetectorME.java 
java SentenceDetectorME

执行时，上述程序读取给定的字符串并检测其中的句子并显示以下输出。

Hi. How are you? 
Welcome to Tutorialspoint. 
We provide free tutorials on various technologies

检测句子的位置

我们还可以使用SentenceDetectorME 类的 sentPosDetect() 方法来检测句子的位置。

以下是编写一个程序来检测给定原始文本中句子位置的步骤。

第 1 步：加载模型

句子检测模型由名为SentenceModel的类表示，该类属于opennlp.tools.sentDetect包。

加载句子检测模型 -

• 创建模型的InputStream对象（实例化FileInputStream并将模型的路径以字符串格式传递给其构造函数）。

• 实例化SentenceModel类并将模型的InputStream （对象）作为参数传递给其构造函数，如以下代码块所示。

//Loading sentence detector model 
InputStream inputStream = new FileInputStream("C:/OpenNLP_models/en-sent.bin"); 
SentenceModel model = new SentenceModel(inputStream);

步骤 2：实例化 SentenceDetectorME 类

opennlp.tools.sentDetect包的 SentenceDetectorME 类包含将原始文本拆分为句子的方法。此类使用最大熵模型来评估字符串中的句尾字符，以确定它们是否表示句子的结尾。

实例化此类并传递上一步中创建的模型对象。

//Instantiating the SentenceDetectorME class 
SentenceDetectorME detector = new SentenceDetectorME(model); 

第三步：检测句子的位置

SentenceDetectorME类的sentPosDetect ()方法用于检测传递给它的原始文本中句子的位置。该方法接受一个字符串变量作为参数。

通过将句子的字符串格式作为参数传递给该方法来调用该方法。

//Detecting the position of the sentences in the paragraph  
Span[] spans = detector.sentPosDetect(sentence); 

第四步：打印句子的跨度

SentenceDetectorME类的sentPosDetect ()方法返回Span类型的对象数组。opennlp.tools.util包中名为 Span 的类用于存储集合的起始和结束整数。

您可以将sentPosDetect()方法返回的span存储在Span数组中并打印它们，如以下代码块所示。

//Printing the sentences and their spans of a sentence 
for (Span span : spans)         
System.out.println(paragraph.substring(span); 

例子

以下是检测给定原始文本中的句子的程序。将此程序保存在名为SentenceDetectionME.java的文件中。

import java.io.FileInputStream; 
import java.io.InputStream; 
  
import opennlp.tools.sentdetect.SentenceDetectorME; 
import opennlp.tools.sentdetect.SentenceModel; 
import opennlp.tools.util.Span;

public class SentencePosDetection { 
  
   public static void main(String args[]) throws Exception { 
   
      String paragraph = "Hi. How are you? Welcome to Tutorialspoint. " 
         + "We provide free tutorials on various technologies"; 
       
      //Loading sentence detector model 
      InputStream inputStream = new FileInputStream("C:/OpenNLP_models/en-sent.bin"); 
      SentenceModel model = new SentenceModel(inputStream); 
       
      //Instantiating the SentenceDetectorME class 
      SentenceDetectorME detector = new SentenceDetectorME(model);  
       
      //Detecting the position of the sentences in the raw text 
      Span spans[] = detector.sentPosDetect(paragraph); 
       
      //Printing the spans of the sentences in the paragraph 
      for (Span span : spans)         
         System.out.println(span);  
   } 
}

使用以下命令从命令提示符编译并执行保存的 Java 文件 -

javac SentencePosDetection.java 
java SentencePosDetection

执行时，上述程序读取给定的字符串并检测其中的句子并显示以下输出。

[0..16) 
[17..43) 
[44..93)

句子及其位置

String 类的 substring() 方法接受开始和结束偏移量并返回相应的字符串。我们可以使用此方法将句子及其跨度（位置）打印在一起，如以下代码块所示。

for (Span span : spans)         
   System.out.println(sen.substring(span.getStart(), span.getEnd())+" "+ span); 

以下是从给定的原始文本中检测句子并显示它们及其位置的程序。将此程序保存在名为SentencesAndPosDetection.java的文件中。

import java.io.FileInputStream; 
import java.io.InputStream;  

import opennlp.tools.sentdetect.SentenceDetectorME; 
import opennlp.tools.sentdetect.SentenceModel; 
import opennlp.tools.util.Span; 
   
public class SentencesAndPosDetection { 
  
   public static void main(String args[]) throws Exception { 
     
      String sen = "Hi. How are you? Welcome to Tutorialspoint." 
         + " We provide free tutorials on various technologies"; 
      //Loading a sentence model 
      InputStream inputStream = new FileInputStream("C:/OpenNLP_models/en-sent.bin"); 
      SentenceModel model = new SentenceModel(inputStream); 
       
      //Instantiating the SentenceDetectorME class 
      SentenceDetectorME detector = new SentenceDetectorME(model);  
       
      //Detecting the position of the sentences in the paragraph  
      Span[] spans = detector.sentPosDetect(sen);  
      
      //Printing the sentences and their spans of a paragraph 
      for (Span span : spans)         
         System.out.println(sen.substring(span.getStart(), span.getEnd())+" "+ span);  
   } 
}  

使用以下命令从命令提示符编译并执行保存的 Java 文件 -

javac SentencesAndPosDetection.java 
java SentencesAndPosDetection

执行时，上述程序读取给定的字符串并检测句子及其位置，并显示以下输出。

Hi. How are you? [0..16) 
Welcome to Tutorialspoint. [17..43)  
We provide free tutorials on various technologies [44..93)

句子概率检测

SentenceDetectorME类的getSentenceProbabilities ()方法返回与最近调用 sentDetect() 方法关联的概率。

//Getting the probabilities of the last decoded sequence       
double[] probs = detector.getSentenceProbabilities(); 

以下是打印与 sendDetect() 方法调用相关的概率的程序。将此程序保存在名为SentenceDetectionMEProbs.java的文件中。

import java.io.FileInputStream; 
import java.io.InputStream;  

import opennlp.tools.sentdetect.SentenceDetectorME; 
import opennlp.tools.sentdetect.SentenceModel;  

public class SentenceDetectionMEProbs { 
  
   public static void main(String args[]) throws Exception { 
   
      String sentence = "Hi. How are you? Welcome to Tutorialspoint. " 
         + "We provide free tutorials on various technologies"; 
       
      //Loading sentence detector model 
      InputStream inputStream = new FileInputStream("C:/OpenNLP_models/en-sent.bin");
      SentenceModel model = new SentenceModel(inputStream); 
       
      //Instantiating the SentenceDetectorME class
      SentenceDetectorME detector = new SentenceDetectorME(model);  
      
      //Detecting the sentence 
      String sentences[] = detector.sentDetect(sentence); 
    
      //Printing the sentences 
      for(String sent : sentences)        
         System.out.println(sent);   
         
      //Getting the probabilities of the last decoded sequence       
      double[] probs = detector.getSentenceProbabilities(); 
       
      System.out.println("  "); 
       
      for(int i = 0; i<probs.length; i++) 
         System.out.println(probs[i]); 
   } 
}       

使用以下命令从命令提示符编译并执行保存的 Java 文件 -

javac SentenceDetectionMEProbs.java 
java SentenceDetectionMEProbs

在执行时，上面的程序读取给定的字符串并检测句子并打印它们。此外，它还返回与最近调用 sentDetect() 方法相关的概率，如下所示。

Hi. How are you? 
Welcome to Tutorialspoint. 
We provide free tutorials on various technologies 
   
0.9240246995179983 
0.9957680129995953 
1.0

OpenNLP - 标记化

将给定句子切成更小的部分（标记）的过程称为标记化。一般来说，给定的原始文本根据一组分隔符（主要是空格）进行标记。

标记化用于拼写检查、处理搜索、识别词性、句子检测、文档的文档分类等任务。

使用 OpenNLP 进行标记化

opennlp.tools.tokenize包包含用于执行标记化的类和接口。

为了将给定的句子标记为更简单的片段，OpenNLP 库提供了三个不同的类 -

• SimpleTokenizer - 此类使用字符类标记给定的原始文本。

• WhitespaceTokenizer - 此类使用空格来标记给定的文本。

• TokenizerME - 此类将原始文本转换为单独的标记。它使用最大熵来做出决定。

简单分词器

要使用SimpleTokenizer类对句子进行标记，您需要 -

• 创建相应类的对象。

• 使用tokenize()方法对句子进行标记。

• 打印令牌。

以下是编写对给定原始文本进行标记的程序时应遵循的步骤。

步骤 1 - 实例化相应的类

在这两个类中，没有可用于实例化它们的构造函数。因此，我们需要使用静态变量INSTANCE创建这些类的对象。

SimpleTokenizer tokenizer = SimpleTokenizer.INSTANCE;   

步骤 2 - 对句子进行标记

这两个类都包含一个名为tokenize()的方法。此方法接受字符串格式的原始文本。调用时，它标记给定的字符串并返回字符串（标记）数组。

使用tokenizer()方法对句子进行标记，如下所示。

//Tokenizing the given sentence 
 String tokens[] = tokenizer.tokenize(sentence); 

第 3 步- 打印令牌

对句子进行标记后，您可以使用for 循环打印标记，如下所示。

//Printing the tokens 
for(String token : tokens)       
   System.out.println(token);

例子

以下是使用 SimpleTokenizer 类对给定句子进行标记的程序。将此程序保存在名为SimpleTokenizerExample.java的文件中。

import opennlp.tools.tokenize.SimpleTokenizer;  
public class SimpleTokenizerExample { 
   public static void main(String args[]){ 
     
      String sentence = "Hi. How are you? Welcome to Tutorialspoint. " 
         + "We provide free tutorials on various technologies"; 
    
      //Instantiating SimpleTokenizer class 
      SimpleTokenizer simpleTokenizer = SimpleTokenizer.INSTANCE;  
       
      //Tokenizing the given sentence 
      String tokens[] = simpleTokenizer.tokenize(sentence);  
       
      //Printing the tokens 
      for(String token : tokens) {         
         System.out.println(token);  
      }       
   }  
}

使用以下命令从命令提示符编译并执行保存的 Java 文件 -

javac SimpleTokenizerExample.java 
java SimpleTokenizerExample

执行时，上述程序读取给定的字符串（原始文本），对其进行标记，并显示以下输出 -

Hi 
. 
How 
are 
you 
? 
Welcome 
to 
Tutorialspoint 
. 
We 
provide 
free 
tutorials 
on 
various 
technologies 

空白分词器

要使用WhitespaceTokenizer类标记句子，您需要 -

• 创建相应类的对象。

• 使用tokenize()方法对句子进行标记。

• 打印令牌。

以下是编写对给定原始文本进行标记的程序时应遵循的步骤。

步骤 1 - 实例化相应的类

在这两个类中，没有可用于实例化它们的构造函数。因此，我们需要使用静态变量INSTANCE创建这些类的对象。

WhitespaceTokenizer tokenizer = WhitespaceTokenizer.INSTANCE; 

步骤 2 - 对句子进行标记

这两个类都包含一个名为tokenize()的方法。此方法接受字符串格式的原始文本。调用时，它标记给定的字符串并返回字符串（标记）数组。

使用tokenizer()方法对句子进行标记，如下所示。

//Tokenizing the given sentence 
 String tokens[] = tokenizer.tokenize(sentence); 

第 3 步- 打印令牌

对句子进行标记后，您可以使用for 循环打印标记，如下所示。

//Printing the tokens 
for(String token : tokens)       
   System.out.println(token);

例子

以下是使用WhitespaceTokenizer类标记给定句子的程序。将此程序保存在名为WhitespaceTokenizerExample.java的文件中。

import opennlp.tools.tokenize.WhitespaceTokenizer;  

public class WhitespaceTokenizerExample {  
   
   public static void main(String args[]){ 
     
      String sentence = "Hi. How are you? Welcome to Tutorialspoint. " 
         + "We provide free tutorials on various technologies"; 
    
      //Instantiating whitespaceTokenizer class 
       WhitespaceTokenizer whitespaceTokenizer = WhitespaceTokenizer.INSTANCE;  
       
      //Tokenizing the given paragraph 
      String tokens[] = whitespaceTokenizer.tokenize(sentence);  
       
      //Printing the tokens 
      for(String token : tokens)     
         System.out.println(token);        
   } 
}

使用以下命令从命令提示符编译并执行保存的 Java 文件 -

javac WhitespaceTokenizerExample.java 
java WhitespaceTokenizerExample 

执行时，上述程序读取给定的字符串（原始文本），对其进行标记，并显示以下输出。

Hi. 
How 
are 
you? 
Welcome 
to 
Tutorialspoint. 
We 
provide 
free 
tutorials 
on 
various 
technologies

分词器ME类

OpenNLP 还使用预定义的模型（名为 de-token.bin 的文件）来对句子进行标记。它被训练来标记给定原始文本中的句子。

opennlp.tools.tokenizer包的 TokenizerME 类用于加载此模型，并使用 OpenNLP 库对给定的原始文本进行标记。为此，您需要 -

• 使用TokenizerModel类加载en-token.bin模型。

• 实例化TokenizerME类。

• 使用此类的tokenize()方法对句子进行标记。

以下是编写使用TokenizerME类对给定原始文本中的句子进行标记的程序时应遵循的步骤。

步骤 1 - 加载模型

标记化模型由名为TokenizerModel的类表示，该类属于opennlp.tools.tokenize包。

加载分词器模型 -

• 创建模型的InputStream对象（实例化FileInputStream并将模型的路径以字符串格式传递给其构造函数）。

• 实例化TokenizerModel类，并将模型的InputStream （对象）作为参数传递给其构造函数，如以下代码块所示。

//Loading the Tokenizer model 
InputStream inputStream = new FileInputStream("C:/OpenNLP_models/en-token.bin"); 
TokenizerModel tokenModel = new TokenizerModel(inputStream);

步骤 2 - 实例化 TokenizerME 类

opennlp.tools.tokenize包的 TokenizerME 类包含将原始文本分割成较小部分（标记）的方法。它使用最大熵来做出决定。

实例化此类并传递在上一步中创建的模型对象，如下所示。

//Instantiating the TokenizerME class 
TokenizerME tokenizer = new TokenizerME(tokenModel);

步骤 3 - 对句子进行标记

TokenizerME类的tokenize ()方法用于对传递给它的原始文本进行标记。此方法接受字符串变量作为参数，并返回字符串（标记）数组。

通过将句子的 String 格式传递给此方法来调用此方法，如下所示。

//Tokenizing the given raw text 
String tokens[] = tokenizer.tokenize(paragraph);

例子

以下是标记给定原始文本的程序。将此程序保存在名为TokenizerMEExample.java的文件中。

import java.io.FileInputStream; 
import java.io.InputStream; 
import opennlp.tools.tokenize.TokenizerME; 
import opennlp.tools.tokenize.TokenizerModel;  

public class TokenizerMEExample { 
  
   public static void main(String args[]) throws Exception{     
     
      String sentence = "Hi. How are you? Welcome to Tutorialspoint. " 
            + "We provide free tutorials on various technologies"; 
       
      //Loading the Tokenizer model 
      InputStream inputStream = new FileInputStream("C:/OpenNLP_models/en-token.bin"); 
      TokenizerModel tokenModel = new TokenizerModel(inputStream); 
       
      //Instantiating the TokenizerME class 
      TokenizerME tokenizer = new TokenizerME(tokenModel); 
       
      //Tokenizing the given raw text 
      String tokens[] = tokenizer.tokenize(sentence);       
          
      //Printing the tokens  
      for (String a : tokens) 
         System.out.println(a); 
   } 
} 

使用以下命令从命令提示符编译并执行保存的 Java 文件 -

javac TokenizerMEExample.java 
java TokenizerMEExample

执行时，上述程序读取给定的字符串并检测其中的句子并显示以下输出 -

Hi 
. 
How 
are 
you 
? 
Welcome 
to 
Tutorialspoint 
. 
We 
provide 
free 
tutorials 
on 
various 
technologie

检索代币的位置

我们还可以使用tokenizePos()方法获取标记的位置或跨度。这是opennlp.tools.tokenize包的 Tokenizer 接口的方法。由于所有（三个）Tokenizer 类都实现了此接口，因此您可以在所有类中找到此方法。

此方法接受字符串形式的句子或原始文本，并返回Span类型的对象数组。

您可以使用tokenizePos()方法获取令牌的位置，如下所示 -

//Retrieving the tokens 
tokenizer.tokenizePos(sentence); 

打印位置（跨度）

opennlp.tools.util包中名为Span的类用于存储集合的起始和结束整数。

您可以将tokenizePos()方法返回的 Span 存储在 Span 数组中并打印它们，如以下代码块所示。

//Retrieving the tokens 
Span[] tokens = tokenizer.tokenizePos(sentence);
//Printing the spans of tokens 
for( Span token : tokens)        
   System.out.println(token);

将代币及其位置打印在一起

String 类的 substring() 方法接受开始和结束偏移量并返回相应的字符串。我们可以使用此方法将标记及其跨度（位置）一起打印，如以下代码块所示。

//Printing the spans of tokens 
for(Span token : tokens)  
   System.out.println(token +" "+sent.substring(token.getStart(), token.getEnd()));

示例（简单标记器）

以下是使用SimpleTokenizer类检索原始文本的标记范围的程序。它还打印令牌及其位置。将此程序保存在名为SimpleTokenizerSpans.java的文件中。

import opennlp.tools.tokenize.SimpleTokenizer; 
import opennlp.tools.util.Span;  

public class SimpleTokenizerSpans {  
   public static void main(String args[]){ 
     
      String sent = "Hi. How are you? Welcome to Tutorialspoint. " 
         + "We provide free tutorials on various technologies"; 
    
      //Instantiating SimpleTokenizer class 
      SimpleTokenizer simpleTokenizer = SimpleTokenizer.INSTANCE;  
       
      //Retrieving the boundaries of the tokens 
      Span[] tokens = simpleTokenizer.tokenizePos(sent);  
       
      //Printing the spans of tokens 
      for( Span token : tokens)
         System.out.println(token +" "+sent.substring(token.getStart(), token.getEnd()));          
   } 
}      

使用以下命令从命令提示符编译并执行保存的 Java 文件 -

javac SimpleTokenizerSpans.java 
java SimpleTokenizerSpans 

执行时，上述程序读取给定的字符串（原始文本），对其进行标记，并显示以下输出 -

[0..2) Hi 
[2..3) . 
[4..7) How 
[8..11) are 
[12..15) you 
[15..16) ? 
[17..24) Welcome 
[25..27) to 
[28..42) Tutorialspoint 
[42..43) . 
[44..46) We 
[47..54) provide 
[55..59) free 
[60..69) tutorials 
[70..72) on 
[73..80) various 
[81..93) technologies 

示例（WhitespaceTokenizer）

以下是使用WhitespaceTokenizer类检索原始文本的标记范围的程序。它还打印令牌及其位置。将此程序保存在名为WhitespaceTokenizerSpans.java的文件中。

import opennlp.tools.tokenize.WhitespaceTokenizer;
import opennlp.tools.util.Span; 
public class WhitespaceTokenizerSpans {  
   public static void main(String args[]){ 
     
      String sent = "Hi. How are you? Welcome to Tutorialspoint. " 
         + "We provide free tutorials on various technologies"; 
    
      //Instantiating SimpleTokenizer class 
      WhitespaceTokenizer whitespaceTokenizer = WhitespaceTokenizer.INSTANCE;  
       
      //Retrieving the tokens 
      Span[] tokens = whitespaceTokenizer.tokenizePos(sent);  
       
      //Printing the spans of tokens 
      for( Span token : tokens) 
         System.out.println(token +" 
            "+sent.substring(token.getStart(), token.getEnd()));        
   } 
} 

使用以下命令从命令提示符编译并执行保存的 java 文件

javac WhitespaceTokenizerSpans.java 
java WhitespaceTokenizerSpans

执行时，上述程序读取给定的字符串（原始文本），对其进行标记，并显示以下输出。

[0..3) Hi. 
[4..7) How 
[8..11) are 
[12..16) you? 
[17..24) Welcome 
[25..27) to 
[28..43) Tutorialspoint. 
[44..46) We 
[47..54) provide 
[55..59) free
[60..69) tutorials 
[70..72) on 
[73..80) various 
[81..93) technologies

示例（TokenizerME）

以下是使用TokenizerME类检索原始文本的标记范围的程序。它还打印令牌及其位置。将此程序保存在名为TokenizerMESpans.java的文件中。

import java.io.FileInputStream; 
import java.io.InputStream; 
import opennlp.tools.tokenize.TokenizerME; 
import opennlp.tools.tokenize.TokenizerModel; 
import opennlp.tools.util.Span;  

public class TokenizerMESpans { 
   public static void main(String args[]) throws Exception{     
      String sent = "Hello John how are you welcome to Tutorialspoint"; 
       
      //Loading the Tokenizer model 
      InputStream inputStream = new FileInputStream("C:/OpenNLP_models/en-token.bin"); 
      TokenizerModel tokenModel = new TokenizerModel(inputStream); 
       
      //Instantiating the TokenizerME class 
      TokenizerME tokenizer = new TokenizerME(tokenModel); 
       
      //Retrieving the positions of the tokens 
      Span tokens[] = tokenizer.tokenizePos(sent); 
       
      //Printing the spans of tokens 
      for(Span token : tokens) 
         System.out.println(token +" "+sent.substring(token.getStart(), token.getEnd()));      
   } 
} 

使用以下命令从命令提示符编译并执行保存的 Java 文件 -

javac TokenizerMESpans.java 
java TokenizerMESpans

执行时，上述程序读取给定的字符串（原始文本），对其进行标记，并显示以下输出 -

[0..5) Hello 
[6..10) John 
[11..14) how 
[15..18) are 
[19..22) you 
[23..30) welcome 
[31..33) to 
[34..48) Tutorialspoint 

分词器概率

TokenizerME 类的 getTokenProbabilities() 方法用于获取与最近调用 tokenizePos() 方法关联的概率。

//Getting the probabilities of the recent calls to tokenizePos() method 
double[] probs = detector.getSentenceProbabilities(); 

以下是打印与 tokenizePos() 方法调用相关的概率的程序。将此程序保存在名为TokenizerMEProbs.java的文件中。

import java.io.FileInputStream; 
import java.io.InputStream; 
import opennlp.tools.tokenize.TokenizerME; 
import opennlp.tools.tokenize.TokenizerModel; 
import opennlp.tools.util.Span;  

public class TokenizerMEProbs { 
   
   public static void main(String args[]) throws Exception{     
      String sent = "Hello John how are you welcome to Tutorialspoint"; 
      
      //Loading the Tokenizer model 
      InputStream inputStream = new FileInputStream("C:/OpenNLP_models/en-token.bin"); 
      TokenizerModel tokenModel = new TokenizerModel(inputStream); 
      
      //Instantiating the TokenizerME class 
      TokenizerME tokenizer = new TokenizerME(tokenModel);
      
      //Retrieving the positions of the tokens 
      Span tokens[] = tokenizer.tokenizePos(sent); 
       
      //Getting the probabilities of the recent calls to tokenizePos() method 
      double[] probs = tokenizer.getTokenProbabilities(); 
       
      //Printing the spans of tokens 
      for(Span token : tokens) 
         System.out.println(token +" "+sent.substring(token.getStart(), token.getEnd()));      
         System.out.println("  "); 
         for(int i = 0; i<probs.length; i++) 
            System.out.println(probs[i]);          
   } 
}      

使用以下命令从命令提示符编译并执行保存的 Java 文件 -

javac TokenizerMEProbs.java 
java TokenizerMEProbs 

在执行时，上面的程序读取给定的字符串并对句子进行标记并打印它们。此外，它还返回与最近调用 tokenizerPos() 方法相关的概率。

[0..5) Hello 
[6..10) John 
[11..14) how 
[15..18) are 
[19..22) you 
[23..30) welcome 
[31..33) to 
[34..48) Tutorialspoint 
   
1.0 
1.0 
1.0 
1.0 
1.0 
1.0 
1.0 
1.0

OpenNLP - 命名实体识别

从给定文本中查找名称、人物、地点和其他实体的过程称为命名实体识别(NER)。在本章中，我们将讨论如何使用 OpenNLP 库通过 Java 程序进行 NER。

使用开放 NLP 的命名实体识别

为了执行各种 NER 任务，OpenNLP 使用不同的预定义模型，即 en-nerdate.bn、en-ner-location.bin、en-ner-organization.bin、en-ner-person.bin 和 en-ner-time。垃圾桶。所有这些文件都是预定义的模型，经过训练可以检测给定原始文本中的各个实体。

opennlp.tools.namefind包包含用于执行 NER 任务的类和接口。要使用 OpenNLP 库执行 NER 任务，您需要 -

• 使用TokenNameFinderModel类加载相应的模型。

• 实例化NameFinder类。

• 找到名字并打印出来。

以下是编写从给定原始文本中检测名称实体的程序时应遵循的步骤。

第 1 步：加载模型

句子检测模型由名为TokenNameFinderModel的类表示，该类属于opennlp.tools.namefind包。

加载 NER 模型 -

• 创建模型的InputStream对象（实例化 FileInputStream 并将字符串格式的相应 NER 模型的路径传递给其构造函数）。

• 实例化TokenNameFinderModel类，并将模型的InputStream （对象）作为参数传递给其构造函数，如以下代码块所示。

//Loading the NER-person model 
InputStream inputStreamNameFinder = new FileInputStream(".../en-nerperson.bin");       
TokenNameFinderModel model = new TokenNameFinderModel(inputStreamNameFinder);

步骤 2：实例化 NameFinderME 类

opennlp.tools.namefind包的 NameFinderME 类包含执行 NER 任务的方法。此类使用最大熵模型来查找给定原始文本中的命名实体。

实例化此类并传递在上一步中创建的模型对象，如下所示 -

//Instantiating the NameFinderME class 
NameFinderME nameFinder = new NameFinderME(model);

第三步：找出句子中的名字

NameFinderME类的find ()方法用于检测传递给它的原始文本中的名称。该方法接受一个字符串变量作为参数。

通过将句子的字符串格式传递给此方法来调用此方法。

//Finding the names in the sentence 
Span nameSpans[] = nameFinder.find(sentence);

第四步：打印句子中名字的跨度

NameFinderME类的find ()方法返回 Span 类型的对象数组。opennlp.tools.util包中名为 Span 的类用于存储集合的起始和结束整数。

您可以将find()方法返回的范围存储在 Span 数组中并打印它们，如以下代码块所示。

//Printing the sentences and their spans of a sentence 
for (Span span : spans)         
System.out.println(paragraph.substring(span);

命名实体示例

以下程序读取给定的句子并识别其中人名的跨度。将此程序保存在名为NameFinderME_Example.java的文件中。

import java.io.FileInputStream; 
import java.io.InputStream;  

import opennlp.tools.namefind.NameFinderME; 
import opennlp.tools.namefind.TokenNameFinderModel; 
import opennlp.tools.util.Span;  

public class NameFinderME_Example { 
   public static void main(String args[]) throws Exception{ 
      /Loading the NER - Person model       InputStream inputStream = new 
         FileInputStream("C:/OpenNLP_models/en-ner-person.bin"); 
      TokenNameFinderModel model = new TokenNameFinderModel(inputStream);
      
      //Instantiating the NameFinder class 
      NameFinderME nameFinder = new NameFinderME(model); 
    
      //Getting the sentence in the form of String array  
      String [] sentence = new String[]{ 
         "Mike", 
         "and", 
         "Smith", 
         "are", 
         "good", 
         "friends" 
      }; 
       
      //Finding the names in the sentence 
      Span nameSpans[] = nameFinder.find(sentence); 
       
      //Printing the spans of the names in the sentence 
      for(Span s: nameSpans) 
         System.out.println(s.toString());    
   }    
}      

使用以下命令从命令提示符编译并执行保存的 Java 文件 -

javac NameFinderME_Example.java 
java NameFinderME_Example

执行时，上述程序读取给定的字符串（原始文本），检测其中人员的姓名，并显示他们的位置（跨度），如下所示。

[0..1) person 
[2..3) person 

姓名及其职位

String 类的 substring() 方法接受开始和结束偏移量并返回相应的字符串。我们可以使用此方法将名称及其跨度（位置）一起打印，如以下代码块所示。

for(Span s: nameSpans)        
   System.out.println(s.toString()+"  "+tokens[s.getStart()]);

以下程序用于从给定的原始文本中检测名称并显示它们及其位置。将此程序保存在名为NameFinderSentences.java的文件中。

import java.io.FileInputStream; 
import java.io.InputStream;  

import opennlp.tools.namefind.NameFinderME; 
import opennlp.tools.namefind.TokenNameFinderModel; 
import opennlp.tools.tokenize.TokenizerME; 
import opennlp.tools.tokenize.TokenizerModel; 
import opennlp.tools.util.Span;  

public class NameFinderSentences {  
   public static void main(String args[]) throws Exception{        
      
      //Loading the tokenizer model 
      InputStream inputStreamTokenizer = new 
         FileInputStream("C:/OpenNLP_models/entoken.bin");
      TokenizerModel tokenModel = new TokenizerModel(inputStreamTokenizer); 
       
      //Instantiating the TokenizerME class 
      TokenizerME tokenizer = new TokenizerME(tokenModel); 
       
      //Tokenizing the sentence in to a string array 
      String sentence = "Mike is senior programming 
      manager and Rama is a clerk both are working at 
      Tutorialspoint"; 
      String tokens[] = tokenizer.tokenize(sentence); 
       
      //Loading the NER-person model 
      InputStream inputStreamNameFinder = new 
         FileInputStream("C:/OpenNLP_models/enner-person.bin");       
      TokenNameFinderModel model = new TokenNameFinderModel(inputStreamNameFinder);
      
      //Instantiating the NameFinderME class 
      NameFinderME nameFinder = new NameFinderME(model);       
      
      //Finding the names in the sentence 
      Span nameSpans[] = nameFinder.find(tokens);        
      
      //Printing the names and their spans in a sentence 
      for(Span s: nameSpans)        
         System.out.println(s.toString()+"  "+tokens[s.getStart()]);