Opennlp-quick-guide

提供：Dev Guides
移動先:案内、検索

OpenNLP-概要

NLPは、Webページやテキストドキュメントなどの自然言語ソースから意味のある有用な情報を引き出すために使用されるツールのセットです。

Open NLPとは何ですか？

Apache OpenNLP は、自然言語テキストの処理に使用されるオープンソースのJavaライブラリです。 このライブラリを使用して、効率的なテキスト処理サービスを構築できます。

OpenNLPは、トークン化、文のセグメンテーション、品詞タグ付け、名前付きエンティティ抽出、チャンク化、解析、相互参照解決などのサービスを提供します。

OpenNLPの機能

OpenNLPの注目すべき機能は次のとおりです-

  • 名前付きエンティティ認識（NER）-Open NLPはNERをサポートします。これを使用して、クエリの処理中でも場所、人、物の名前を抽出できます。
  • Summarize - summarize 機能を使用すると、段落、記事、ドキュメント、またはそれらのコレクションをNLPで要約できます。
  • 検索-OpenNLPでは、指定された単語が変更されたりスペルミスがあったとしても、指定されたテキストで特定の検索文字列またはその同義語を識別することができます。
  • タグ付け（POS）-NLPのタグ付けは、さらなる分析のためにテキストをさまざまな文法要素に分割するために使用されます。
  • 翻訳-NLPでは、翻訳はある言語を別の言語に翻訳するのに役立ちます。
  • 情報のグループ化-NLPのこのオプションは、品詞と同様に、ドキュメントのコンテンツ内のテキスト情報をグループ化します。
  • 自然言語の生成-データベースから情報を生成し、気象分析や医療レポートなどの情報レポートを自動化するために使用されます。
  • フィードバック分析-名前が示すように、製品に関する人々からのさまざまなタイプのフィードバックがNLPによって収集され、製品が彼らの心をつかむのにどれだけ成功しているかを分析します。
  • 音声認識-人間の音声を分析することは困難ですが、NLPにはこの要件のための組み込み機能がいくつかあります。

NLP APIを開く

Apache OpenNLPライブラリは、文の検出、トークン化、名前の検索、品詞のタグ付け、文のチャンク化、解析、相互参照の解決、ドキュメントの分類など、自然言語処理のさまざまなタスクを実行するクラスとインターフェイスを提供します。

これらのタスクに加えて、これらのタスクのいずれかの独自のモデルをトレーニングおよび評価することもできます。

OpenNLP CLI

ライブラリに加えて、OpenNLPはコマンドラインインターフェイス（CLI）も提供しており、モデルのトレーニングと評価を行うことができます。 このトピックの詳細については、このチュートリアルの最後の章で説明します。

OpenNLP CLI

NLPモデルを開く

さまざまなNLPタスクを実行するために、OpenNLPは事前定義されたモデルのセットを提供します。 このセットには、さまざまな言語のモデルが含まれています。

モデルのダウンロード

以下に示す手順に従って、OpenNLPが提供する事前定義モデルをダウンロードできます。

OpenNLPモデル

  • ステップ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/。

Apache OpenNLP

  • ステップ2 *-次に、*ダウンロード*リンクをクリックします。 クリックすると、Apache Software Foundation Distributionディレクトリにリダイレクトされるさまざまなミラーを見つけることができるページに移動します。
  • ステップ3 *-このページには、さまざまなApacheディストリビューションをダウンロードするためのリンクがあります。 それらを参照し、OpenNLPディストリビューションを見つけてクリックします。

配布

  • ステップ4 *-クリックすると、以下に示すように、OpenNLPディストリビューションのインデックスを確認できるディレクトリにリダイレクトされます。

Opennlpのインデックス

利用可能なディストリビューションから最新バージョンをクリックします。

ステップ5 *-各ディストリビューションは、OpenNLPライブラリのソースファイルとバイナリファイルをさまざまな形式で提供します。 ソースおよびバイナリファイル *apache-opennlp-1.6.0-bin.zip および apache-opennlp1.6.0-src.zip （Windows用）をダウンロードします。

OpenNLPのソースおよびバイナリファイル

クラスパスの設定

OpenNLPライブラリをダウンロードした後、 bin ディレクトリへのパスを設定する必要があります。 OpenNLPライブラリをシステムのEドライブにダウンロードしたと仮定します。

さて、以下に記載されている手順に従ってください-

  • ステップ1 *-[マイコンピュータ]を右クリックして、[プロパティ]を選択します。
  • ステップ2 *-[詳細設定]タブの下の[環境変数]ボタンをクリックします。

ステップ3 *-次のスクリーンショットに示すように、 *path 変数を選択し、 Edit ボタンをクリックします。

システム変数パス

ステップ4 *-環境変数の編集ウィンドウで、*新規*ボタンをクリックし、OpenNLPディレクトリ *E：\ apache-opennlp-1.6.0 \ bin のパスを追加し、 OK ボタンをクリックします。次のスクリーンショット。

環境変数の編集ウィンドウ

Eclipseのインストール

ビルドパス*をJARファイルに設定するか、 *pom.xml を使用して、OpenNLPライブラリのEclipse環境を設定できます。

JARファイルへのビルドパスの設定

EclipseにOpenNLPをインストールするには、以下の手順に従います-

  • ステップ1 *-システムにEclipse環境がインストールされていることを確認します。
  • ステップ2 *-Eclipseを開きます。 以下に示すように、[ファイル]→[新規]→[新しいプロジェクトを開く]の順にクリックします。

新しいプロジェクト

  • ステップ3 *-*新しいプロジェクト*ウィザードが表示されます。 このウィザードで、Javaプロジェクトを選択し、[次へ]ボタンをクリックして続行します。

Javaプロジェクト

  • ステップ4 *-次に、*新規Javaプロジェクトウィザード*が表示されます。 ここでは、以下に示すように、新しいプロジェクトを作成し、[次へ]ボタンをクリックする必要があります。

マイプロジェクト

  • ステップ5 *-新しいプロジェクトを作成した後、それを右クリックし、*ビルドパス*を選択して、*ビルドパスの構成*をクリックします。

ビルドパスの構成

ステップ6 *-次に、 *Java Build Path ウィザードが表示されます。 ここで、以下に示すように、 Add External JARs ボタンをクリックします。

Javaビルドパス

ステップ7 *- apache-opennlp-1.6.0フォルダー*の lib フォルダーにあるjarファイル opennlp-tools-1.6.0.jar および opennlp-uima-1.6.0.jar を選択します。 。

Opennlpツール

上記の画面で[開く]ボタンをクリックすると、選択したファイルがライブラリに追加されます。

外部JARの追加

[OK]をクリックすると、必要な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

この章では、このチュートリアルの後続の章で使用するクラスとメソッドについて説明します。

文検出

SentenceModelクラス

このクラスは、指定された生テキストの文を検出するために使用される事前定義モデルを表します。 このクラスは、 opennlp.tools.sentdetect パッケージに属します。

このクラスのコンストラクターは、文検出器モデルファイル（en-sent.bin）の InputStream オブジェクトを受け入れます。

SentenceDetectorMEクラス

このクラスはパッケージ opennlp.tools.sentdetect に属し、生のテキストを文に分割するメソッドが含まれています。 このクラスは、最大エントロピーモデルを使用して文字列内の文末文字を評価し、文末を意味するかどうかを判断します。

このクラスの重要なメソッドは次のとおりです。

S.No Methods and Description
1

sentDetect()

このメソッドは、渡された生のテキスト内の文を検出するために使用されます。 パラメータとして文字列変数を受け取り、指定された生のテキストの文を保持する文字列配列を返します。

2

sentPosDetect()

このメソッドは、指定されたテキスト内の文の位置を検出するために使用されます。 このメソッドは、文を表す文字列変数を受け入れ、 Span 型のオブジェクトの配列を返します。

  • opennlp.tools.util* パッケージの *Span* というクラスは、セットの開始および終了整数を格納するために使用されます。
3

getSentenceProbabilities()

このメソッドは、* sentDetect（）*メソッドの最新の呼び出しに関連付けられた確率を返します。

トークン化

TokenizerModelクラス

このクラスは、指定された文のトークン化に使用される事前定義モデルを表します。 このクラスは、パッケージ opennlp.tools.tokenizer に属します。

このクラスのコンストラクターは、トークナイザーモデルファイル（entoken.bin）の InputStream オブジェクトを受け入れます。

クラス

トークン化を実行するために、OpenNLPライブラリには3つの主要なクラスが用意されています。 3つのクラスはすべて、 Tokenizer というインターフェイスを実装しています。

S.No Classes and Description
1

SimpleTokenizer

このクラスは、文字クラスを使用して、指定された生テキストをトークン化します。

2

WhitespaceTokenizer

このクラスは、空白を使用して、指定されたテキストをトークン化します。

3

TokenizerME

このクラスは、生のテキストを個別のトークンに変換します。 最大エントロピーを使用して決定を行います。

これらのクラスには、次のメソッドが含まれています。

S.No Methods and Description
1

tokenize()

このメソッドは、生のテキストをトークン化するために使用されます。 このメソッドは、パラメーターとしてストリング変数を受け入れ、ストリング（トークン）の配列を返します。

2

sentPosDetect()

このメソッドは、トークンの位置またはスパンを取得するために使用されます。 文字列形式の文（または）生テキストを受け入れ、 Span 型のオブジェクトの配列を返します。

上記の2つのメソッドに加えて、 TokenizerME クラスには* getTokenProbabilities（）*メソッドがあります。

S.No Methods and Description
1

getTokenProbabilities()

このメソッドは、* tokenizePos（）*メソッドの最新の呼び出しに関連付けられた確率を取得するために使用されます。

NameEntityRecognition

TokenNameFinderModelクラス

このクラスは、指定された文の名前付きエンティティを検索するために使用される事前定義モデルを表します。 このクラスは opennlp.tools.namefind パッケージに属します。

このクラスのコンストラクターは、ネームファインダーモデルファイル（enner-person.bin）の InputStream オブジェクトを受け入れます。

NameFinderMEクラス

このクラスは opennlp.tools.namefind パッケージに属し、NERタスクを実行するメソッドが含まれています。 このクラスは、最大エントロピーモデルを使用して、指定された生テキスト内の名前付きエンティティを検索します。

S.No Methods and Description
1

find()

このメソッドは、生のテキスト内の名前を検出するために使用されます。 生のテキストを表すString変数をパラメーターとして受け取り、Span型のオブジェクトの配列を返します。

2

probs()

このメソッドは、最後にデコードされたシーケンスの確率を取得するために使用されます。

品詞を見つける

POSModelクラス

このクラスは、指定された文の品詞にタグを付けるために使用される事前定義モデルを表します。 このクラスは、パッケージ opennlp.tools.postag に属します。

このクラスのコンストラクターは、pos-taggerモデルファイル（enpos-maxent.bin）の InputStream オブジェクトを受け入れます。

POSTaggerMEクラス

このクラスはパッケージ opennlp.tools.postag に属し、指定された生テキストの品詞を予測するために使用されます。 最大エントロピーを使用して決定を行います。

S.No Methods and Description
1

tag()

このメソッドは、トークンPOSタグの文を割り当てるために使用されます。 このメソッドは、トークンの配列（String）をパラメーターとして受け入れ、タグ（配列）を返します。

2

getSentenceProbabilities()

このメソッドは、最近タグ付けされた文の各タグの確率を取得するために使用されます。

文の解析

ParserModelクラス

このクラスは、指定された文の解析に使用される事前定義モデルを表します。 このクラスは opennlp.tools.parser パッケージに属します。

このクラスのコンストラクターは、パーサーモデルファイル（en-parserchunking.bin）の InputStream オブジェクトを受け入れます。

パーサーファクトリクラス

このクラスはパッケージ opennlp.tools.parser に属し、パーサーの作成に使用されます。

S.No Methods and Description
1

create()

これは静的メソッドであり、パーサーオブジェクトの作成に使用されます。 このメソッドは、パーサーモデルファイルのFilestreamオブジェクトを受け入れます。

ParserToolクラス

このクラスは opennlp.tools.cmdline.parser パッケージに属し、コンテンツの解析に使用されます。

S.No Methods and Description
1

parseLine()

  • ParserTool* クラスのこのメソッドは、OpenNLPの生テキストを解析するために使用されます。 このメソッドは受け入れます-
  • 解析するテキストを表す文字列変数。
  • パーサーオブジェクト。
  • 実行する解析の数を表す整数。

チャンキング

ChunkerModelクラス

このクラスは、文を小さなチャンクに分割するために使用される事前定義モデルを表します。 このクラスは opennlp.tools.chunker パッケージに属します。

このクラスのコンストラクターは、 chunker モデルファイル（enchunker.bin）の InputStream オブジェクトを受け入れます。

ChunkerMEクラス

このクラスは opennlp.tools.chunker という名前のパッケージに属し、指定された文を小さなチャンクに分割するために使用されます。

S.No Methods and Description
1

chunk()

このメソッドは、指定された文を小さなチャンクに分割するために使用されます。 文のトークンと* P arts O f S *peechタグをパラメーターとして受け入れます。

2
  • probs()*

このメソッドは、最後にデコードされたシーケンスの確率を返します。

OpenNLP-文検出

自然言語の処理中に、文の開始と終了を決定することは、対処すべき問題の1つです。 このプロセスは、* S' 文章 B *音響'曖昧さ回避（SBD）または単に文の区切りとして知られています。

特定のテキスト内の文を検出するために使用する手法は、テキストの言語によって異なります。

Javaを使用した文検出

正規表現と一連の単純なルールを使用して、Javaで指定されたテキスト内の文を検出できます。

たとえば、ピリオド、疑問符、または感嘆符が指定されたテキストの文を終了すると仮定し、 String クラスの* split（）*メソッドを使用して文を分割できます。 ここでは、文字列形式の正規表現を渡す必要があります。

以下は、Java正規表現*（split method）を使用して、指定されたテキスト内の文を決定するプログラムです。 このプログラムを *SentenceDetection_RE.java という名前のファイルに保存します。 

public class SentenceDetection_RE {
   public static void main(String args[]){

      String sentence = " Hi. How are you? Welcome to finddevguides. "
         + "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 finddevguides
We provide free tutorials on various technologies

OpenNLPを使用した文検出

文を検出するために、OpenNLPは事前定義モデル、 en-sent.bin という名前のファイルを使用します。 この事前定義モデルは、指定された生テキストの文を検出するようにトレーニングされています。 

*opennlp.tools.sentdetect* パッケージには、文検出タスクの実行に使用されるクラスとインターフェースが含まれています。

OpenNLPライブラリを使用して文を検出するには、する必要があります-

  • SentenceModel クラスを使用して en-sent.bin モデルを読み込みます
  • SentenceDetectorME クラスをインスタンス化します。
  • このクラスの* sentDetect（）*メソッドを使用して文を検出します。

以下は、与えられた生のテキストから文を検出するプログラムを書くために従うべきステップです。

ステップ1：モデルの読み込み

文検出のモデルは、パッケージ opennlp.tools.sentdetect に属する SentenceModel というクラスで表されます。

文検出モデルをロードするには-

  • モデルの InputStream オブジェクトを作成します（FileInputStreamをインスタンス化し、モデルのパスをString形式でコンストラクターに渡します）。
  • 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);

ステップ3：文を検出する

*SentenceDetectorME* クラスの* sentDetect（）*メソッドを使用して、渡された生テキスト内の文を検出します。 このメソッドは、パラメーターとしてString変数を受け入れます。

文の文字列形式をこのメソッドに渡すことにより、このメソッドを呼び出します。 

//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 finddevguides. "
         + "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 finddevguides.
We provide free tutorials on various technologies

文の位置を検出する

  • SentenceDetectorMEクラス*のsentPosDetect（）メソッドを使用して、文の位置を検出することもできます。

以下は、与えられた生のテキストから文の位置を検出するプログラムを書くために従うべきステップです。

ステップ1：モデルの読み込み

文検出のモデルは、パッケージ opennlp.tools.sentdetect に属する SentenceModel というクラスで表されます。

文検出モデルをロードするには-

  • モデルの InputStream オブジェクトを作成します（FileInputStreamをインスタンス化し、モデルのパスをString形式でコンストラクターに渡します）。
  • 次のコードブロックに示すように、 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);

ステップ3：文の位置を検出する

*SentenceDetectorME* クラスの* sentPosDetect（）*メソッドは、渡された未加工テキスト内の文の位置を検出するために使用されます。 このメソッドは、パラメーターとしてString変数を受け入れます。

文の文字列形式をパラメータとしてこのメ​​ソッドに渡すことにより、このメソッドを呼び出します。 

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

ステップ4：文の範囲を印刷する

*SentenceDetectorME* クラスの* sentPosDetect（）*メソッドは、 *Span* 型のオブジェクトの配列を返します。 *opennlp.tools.util* パッケージのSpanという名前のクラスは、セットの開始および終了整数を格納するために使用されます。

次のコードブロックに示すように、* sentPosDetect（）*メソッドによって返されたスパンを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 finddevguides. "
         + "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（）メソッドは、 *begin および end offsets を受け入れ、それぞれの文字列を返します。 次のコードブロックに示すように、このメソッドを使用して、文とそのスパン（位置）を一緒に印刷できます。 

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 finddevguides."
         + " 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 finddevguides. [17..43)
We provide free tutorials on various technologies [44..93)

文の確率の検出

*SentenceDetectorME* クラスの* getSentenceProbabilities（）*メソッドは、sendDetect（）メソッドの最新の呼び出しに関連付けられた確率を返します。
//Getting the probabilities of the last decoded sequence
double[] probs = detector.getSentenceProbabilities();

以下は、sentDetect（）メソッドの呼び出しに関連する確率を出力するプログラムです。 このプログラムを 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 finddevguides. "
         + "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 finddevguides.
We provide free tutorials on various technologies

0.9240246995179983
0.9957680129995953
1.0

OpenNLP-トークン化

与えられた文を小さな部分（トークン）に切り刻むプロセスは、*トークン化*として知られています。 一般に、指定された生のテキストは、区切り文字（ほとんどが空白）のセットに基づいてトークン化されます。

トークン化は、スペルチェック、検索処理、品詞の識別、文の検出、ドキュメントのドキュメント分類などのタスクで使用されます。

OpenNLPを使用したトークン化

*opennlp.tools.tokenize* パッケージには、トークン化の実行に使用されるクラスとインターフェースが含まれています。

与えられた文をより単純なフラグメントにトークン化するために、OpenNLPライブラリは3つの異なるクラスを提供します-

  • SimpleTokenizer -このクラスは、文字クラスを使用して、指定された生テキストをトークン化します。
  • WhitespaceTokenizer -このクラスは、指定されたテキストをトークン化するために空白を使用します。
  • TokenizerME -このクラスは、生のテキストを個別のトークンに変換します。 最大エントロピーを使用して決定を行います。

SimpleTokenizer

*SimpleTokenizer* クラスを使用して文をトークン化するには、以下を行う必要があります-
  • それぞれのクラスのオブジェクトを作成します。
  • * tokenize（）*メソッドを使用して文をトークン化します。
  • トークンを印刷します。

以下は、与えられた生のテキストをトークン化するプログラムを書くために従うべきステップです。

  • ステップ1 *-それぞれのクラスをインスタンス化する

両方のクラスに、それらをインスタンス化するために利用できるコンストラクタはありません。 したがって、静的変数 INSTANCE を使用してこれらのクラスのオブジェクトを作成する必要があります。 

SimpleTokenizer tokenizer = SimpleTokenizer.INSTANCE;
  • ステップ2 *-文をトークン化する

これらの両方のクラスには、* tokenize（）*というメソッドが含まれています。 このメソッドは、文字列形式の生テキストを受け入れます。 呼び出し時に、指定された文字列をトークン化し、文字列（トークン）の配列を返します。

以下に示すように、* tokenizer（）*メソッドを使用して文をトークン化します。 

//Tokenizing the given sentence
 String tokens[] = tokenizer.tokenize(sentence);
  • ステップ3 *-トークンを印刷する

文をトークン化した後、以下に示すように、 for loop を使用してトークンを印刷できます。 

//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 finddevguides. "
         + "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
finddevguides
.
We
provide
free
tutorials
on
various
technologies

WhitespaceTokenizer

*WhitespaceTokenizer* クラスを使用して文をトークン化するには、以下を行う必要があります-
  • それぞれのクラスのオブジェクトを作成します。
  • * tokenize（）*メソッドを使用して文をトークン化します。
  • トークンを印刷します。

以下は、与えられた生のテキストをトークン化するプログラムを書くために従うべきステップです。

  • ステップ1 *-それぞれのクラスをインスタンス化する

両方のクラスに、それらをインスタンス化するために利用できるコンストラクタはありません。 したがって、静的変数 INSTANCE を使用してこれらのクラスのオブジェクトを作成する必要があります。 

WhitespaceTokenizer tokenizer = WhitespaceTokenizer.INSTANCE;
  • ステップ2 *-文をトークン化する

これらの両方のクラスには、* tokenize（）*というメソッドが含まれています。 このメソッドは、文字列形式の生テキストを受け入れます。 呼び出し時に、指定された文字列をトークン化し、文字列（トークン）の配列を返します。

以下に示すように、* tokenizer（）*メソッドを使用して文をトークン化します。 

//Tokenizing the given sentence
 String tokens[] = tokenizer.tokenize(sentence);
  • ステップ3 *-トークンを印刷する

文をトークン化した後、以下に示すように、 for loop を使用してトークンを印刷できます。 

//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 finddevguides. "
         + "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
finddevguides.
We
provide
free
tutorials
on
various
technologies

TokenizerMEクラス

OpenNLPは、定義済みのモデルであるde-token.binというファイルを使用して、文をトークン化します。 与えられた生のテキストの文をトークン化するように訓練されています。 

*opennlp.tools.tokenizer* パッケージの *TokenizerME* クラスを使用してこのモデルをロードし、OpenNLPライブラリを使用して指定された生テキストをトークン化します。 そうするために、あなたはする必要があります-
  • TokenizerModel クラスを使用して en-token.bin モデルをロードします。
  • TokenizerME クラスをインスタンス化します。
  • このクラスの* tokenize（）*メソッドを使用して文をトークン化します。

以下は、 TokenizerME クラスを使用して、指定された生テキストから文をトークン化するプログラムを作成するために従うべき手順です。

  • ステップ1 *-モデルの読み込み

トークン化のモデルは、 opennlp.tools.tokenize パッケージに属する TokenizerModel というクラスで表されます。

トークナイザーモデルをロードするには-

  • モデルの InputStream オブジェクトを作成します（FileInputStreamをインスタンス化し、モデルのパスをString形式でコンストラクターに渡します）。
  • 次のコードブロックに示すように、 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（）*メソッドは、渡された生テキストをトークン化するために使用されます。 このメソッドは、パラメーターとしてストリング変数を受け入れ、ストリング（トークン）の配列を返します。

次のように、文の文字列形式をこのメソッドに渡すことにより、このメソッドを呼び出します。 

//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 finddevguides. "
            + "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
finddevguides
.
We
provide
free
tutorials
on
various
technologie

トークンの位置を取得する

  • tokenizePos（）メソッドを使用して、トークンの位置または*スパン*を取得することもできます。 これは、パッケージ *opennlp.tools.tokenize のTokenizerインターフェイスのメソッドです。 すべての（3つの）トークナイザークラスがこのインターフェイスを実装しているため、すべてのクラスでこのメソッドを見つけることができます。

このメソッドは、文字列の形式の文または生のテキストを受け入れ、 Span 型のオブジェクトの配列を返します。

次のように、* tokenizePos（）*メソッドを使用して、トークンの位置を取得できます- 

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

位置の印刷（スパン）

*opennlp.tools.util* パッケージの *Span* というクラスは、セットの開始および終了整数を格納するために使用されます。

次のコードブロックに示すように、* tokenizePos（）*メソッドによって返されたスパンをSpan配列に格納して印刷できます。 

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

トークンとその位置を一緒に印刷する

Stringクラスの* substring（）メソッドは、 *begin および end オフセットを受け入れ、それぞれの文字列を返します。 次のコードブロックに示すように、このメソッドを使用して、トークンとそのスパン（位置）を一緒に印刷できます。 

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

例（SimpleTokenizer）

以下は、 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 finddevguides. "
         + "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) finddevguides
[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 finddevguides. "
         + "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) finddevguides.
[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 finddevguides";

     //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) finddevguides

トークナイザーの確率

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 finddevguides";

     //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) finddevguides

1.0
1.0
1.0
1.0
1.0
1.0
1.0
1.0

OpenNLP-名前付きエンティティの認識

特定のテキストから名前、人、場所、およびその他のエンティティを見つけるプロセスは、* N amed E ntity R * ecognition（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：モデルの読み込み

文検出のモデルは、パッケージ opennlp.tools.namefind に属する TokenNameFinderModel という名前のクラスで表されます。

NERモデルを読み込むには-

  • モデルの InputStream オブジェクトを作成します（FileInputStreamをインスタンス化し、適切なNERモデルのパスをString形式でコンストラクターに渡します）。
  • 次のコードブロックに示すように、 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);

ステップ3：文中の名前を見つける

*NameFinderME* クラスの* find（）*メソッドは、渡された生テキストの名前を検出するために使用されます。 このメソッドは、パラメーターとしてString変数を受け入れます。

文の文字列形式をこのメソッドに渡すことにより、このメソッドを呼び出します。 

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

ステップ4：文中の名前のスパンを印刷する

*NameFinderME* クラスの* find（）*メソッドは、Span型のオブジェクトの配列を返します。 *opennlp.tools.util* パッケージのSpanという名前のクラスは、セットの *start* および *end* 整数を格納するために使用されます。

次のコードブロックに示すように、* find（）*メソッドによって返されたスパンをSpan配列に格納して印刷できます。 

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

以下は、与えられた文を読み、その中の人の名前の範囲を認識するプログラムです。 このプログラムを 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（）メソッドは、 *begin および end offsets を受け入れ、それぞれの文字列を返します。 次のコードブロックに示すように、このメソッドを使用して、名前とそのスパン（位置）を一緒に印刷できます。 

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
      finddevguides";
      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()]);
   }
}

次のコマンドを使用して、コマンドプロンプトから保存したJavaファイルをコンパイルして実行します- 

javac NameFinderSentences.java
java NameFinderSentences

実行時に、上記のプログラムは指定された文字列（生テキスト）を読み取り、その中の人物の名前を検出し、以下に示すようにその位置（スパン）を表示します。 

[0..1) person  Mike

場所の名前を見つける

さまざまなモデルをロードすることにより、さまざまな名前のエンティティを検出できます。 以下は、 en-ner-location.bin モデルをロードし、指定された文の場所名を検出するJavaプログラムです。 このプログラムを LocationFinder.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 LocationFinder {
   public static void main(String args[]) throws Exception{

      InputStream inputStreamTokenizer = new
         FileInputStream("C:/OpenNLP_models/entoken.bin");
      TokenizerModel tokenModel = new TokenizerModel(inputStreamTokenizer);

     //String paragraph = "Mike and Smith are classmates";
      String paragraph = "finddevguides is located in Hyderabad";

     //Instantiating the TokenizerME class
      TokenizerME tokenizer = new TokenizerME(tokenModel);
      String tokens[] = tokenizer.tokenize(paragraph);

     //Loading the NER-location moodel
      InputStream inputStreamNameFinder = new
         FileInputStream("C:/OpenNLP_models/en- ner-location.bin");
      TokenNameFinderModel model = new TokenNameFinderModel(inputStreamNameFinder);

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

     //Finding the names of a location
      Span nameSpans[] = nameFinder.find(tokens);
     //Printing the spans of the locations in the sentence
      for(Span s: nameSpans)
         System.out.println(s.toString()+"  "+tokens[s.getStart()]);
   }
}

次のコマンドを使用して、コマンドプロンプトから保存したJavaファイルをコンパイルして実行します- 

javac LocationFinder.java
java LocationFinder

上記のプログラムは、実行時に、指定された文字列（生テキスト）を読み取り、その中の人物の名前を検出し、以下に示すようにその位置（スパン）を表示します。 

[4..5) location  Hyderabad

NameFinderの確率

*NameFinderME* クラスの** probs（）**メソッドは、最後にデコードされたシーケンスの確率を取得するために使用されます。
double[] probs = nameFinder.probs();

以下は、確率を出力するプログラムです。 このプログラムを 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 finddevguides";

     //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

実行時に、上記のプログラムは指定された文字列を読み取り、文をトークン化し、それらを出力します。 さらに、以下に示すように、最後にデコードされたシーケンスの確率も返します。 

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

1.0
1.0
1.0
1.0
1.0
1.0
1.0
1.0

OpenNLP-品詞の検索

OpenNLPを使用すると、特定の文の品詞を検出して印刷することもできます。 品詞のフルネームの代わりに、OpenNLPは各品詞の短い形式を使用します。 次の表は、OpenNLPによって検出されたスピーチのさまざまな部分とその意味を示しています。

Parts of Speech Meaning of parts of speech
NN Noun, singular or mass
DT Determiner
VB Verb, base form
VBD Verb, past tense
VBZ Verb, third person singular present
IN Preposition or subordinating conjunction
NNP Proper noun, singular
TO to
JJ Adjective

品詞のタグ付け

文の品詞にタグを付けるために、OpenNLPは en-posmaxent.bin という名前のファイルであるモデルを使用します。 これは、所定の生テキストの品詞にタグを付けるように訓練された事前定義モデルです。 

*opennlp.tools.postag* パッケージの *POSTaggerME* クラスは、このモデルをロードし、OpenNLPライブラリを使用して、指定された生テキストの品詞にタグを付けるために使用されます。 そうするために、あなたはする必要があります-
  • POSModel クラスを使用して en-pos-maxent.bin モデルを読み込みます。
  • POSTaggerME クラスをインスタンス化します。
  • 文をトークン化します。
  • * tag（）*メソッドを使用してタグを生成します。
  • POSSample クラスを使用してトークンとタグを印刷します。

以下は、 POSTaggerME クラスを使用して、指定された生テキストのスピーチの部分にタグを付けるプログラムを作成するために従うべき手順です。

ステップ1：モデルを読み込む

POSタグ付けのモデルは、パッケージ opennlp.tools.postag に属する POSModel という名前のクラスで表されます。

トークナイザーモデルをロードするには-

  • モデルの InputStream オブジェクトを作成します（FileInputStreamをインスタンス化し、モデルのパスをString形式でコンストラクターに渡します）。
  • 次のコードブロックに示すように、 POSModel クラスをインスタンス化し、モデルの InputStream （オブジェクト）をそのコンストラクタへのパラメータとして渡します-
//Loading Parts of speech-maxent model
InputStream inputStream = new FileInputStream("C:/OpenNLP_models/en-pos-maxent.bin");
POSModel model = new POSModel(inputStream);

ステップ2：POSTaggerMEクラスのインスタンス化

パッケージ opennlp.tools.postag の POSTaggerME クラスは、指定された生テキストの品詞を予測するために使用されます。 最大エントロピーを使用して決定を行います。

以下に示すように、このクラスをインスタンス化し、前の手順で作成されたモデルオブジェクトを渡します- 

//Instantiating POSTaggerME class
POSTaggerME tagger = new POSTaggerME(model);

ステップ3：文のトークン化

*whitespaceTokenizer* クラスの* tokenize（）*メソッドは、渡された生テキストをトークン化するために使用されます。 このメソッドは、パラメーターとしてストリング変数を受け入れ、ストリング（トークン）の配列を返します。
*whitespaceTokenizer* クラスをインスタンス化し、文の文字列形式をこのメソッドに渡すことでこのメソッドを呼び出します。
//Tokenizing the sentence using WhitespaceTokenizer class
WhitespaceTokenizer whitespaceTokenizer= WhitespaceTokenizer.INSTANCE;
String[] tokens = whitespaceTokenizer.tokenize(sentence);

ステップ4：タグを生成する

*whitespaceTokenizer* クラスの* tag（）*メソッドは、トークンの文にPOSタグを割り当てます。 このメソッドは、トークンの配列（String）をパラメーターとして受け入れ、タグ（配列）を返します。

前のステップで生成されたトークンを渡すことにより、* tag（）*メソッドを呼び出します。 

//Generating tags
String[] tags = tagger.tag(tokens);

ステップ5：トークンとタグを印刷する

*POSSample* クラスは、POSタグ付きの文を表します。 このクラスをインスタンス化するには、（テキストの）トークンの配列とタグの配列が必要です。

このクラスの* toString（）メソッドは、タグ付きの文を返します。 次のコードブロックに示すように、前の手順で作成したトークンとタグ配列を渡してこのクラスをインスタンス化し、その toString（）*メソッドを呼び出します。 

//Instantiating the POSSample class
POSSample sample = new POSSample(tokens, tags);
System.out.println(sample.toString());

例

以下は、与えられた生のテキストの品詞にタグを付けるプログラムです。 このプログラムを* PosTaggerExample.java。*という名前のファイルに保存します 

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

import opennlp.tools.postag.POSModel;
import opennlp.tools.postag.POSSample;
import opennlp.tools.postag.POSTaggerME;
import opennlp.tools.tokenize.WhitespaceTokenizer;

public class PosTaggerExample {

   public static void main(String args[]) throws Exception{

     //Loading Parts of speech-maxent model
      InputStream inputStream = new
         FileInputStream("C:/OpenNLP_models/en-pos-maxent.bin");
      POSModel model = new POSModel(inputStream);

     //Instantiating POSTaggerME class
      POSTaggerME tagger = new POSTaggerME(model);

      String sentence = "Hi welcome to finddevguides";

     //Tokenizing the sentence using WhitespaceTokenizer class
      WhitespaceTokenizer whitespaceTokenizer= WhitespaceTokenizer.INSTANCE;
      String[] tokens = whitespaceTokenizer.tokenize(sentence);

     //Generating tags
      String[] tags = tagger.tag(tokens);

     //Instantiating the POSSample class
      POSSample sample = new POSSample(tokens, tags);
      System.out.println(sample.toString());

   }
}

次のコマンドを使用して、コマンドプロンプトから保存したJavaファイルをコンパイルして実行します- 

javac PosTaggerExample.java
java PosTaggerExample

実行時に、上記のプログラムは指定されたテキストを読み取り、これらの文の品詞を検出して、以下に示すように表示します。 

Hi_NNP welcome_JJ to_TO finddevguides_VB

POSタガーパフォーマンス

以下は、生のテキストの品詞にタグを付けるプログラムです。 また、パフォーマンスを監視し、タガーのパフォーマンスを表示します。 このプログラムを PosTagger_Performance.java という名前のファイルに保存します。 

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

import opennlp.tools.cmdline.PerformanceMonitor;
import opennlp.tools.postag.POSModel;
import opennlp.tools.postag.POSSample;
import opennlp.tools.postag.POSTaggerME;
import opennlp.tools.tokenize.WhitespaceTokenizer;

public class PosTagger_Performance {
   public static void main(String args[]) throws Exception{
     //Loading Parts of speech-maxent model
      InputStream inputStream = new
         FileInputStream("C:/OpenNLP_models/en-pos-maxent.bin");
      POSModel model = new POSModel(inputStream);

     //Creating an object of WhitespaceTokenizer class
      WhitespaceTokenizer whitespaceTokenizer= WhitespaceTokenizer.INSTANCE;

     //Tokenizing the sentence
      String sentence = "Hi welcome to finddevguides";
      String[] tokens = whitespaceTokenizer.tokenize(sentence);

     //Instantiating POSTaggerME class
      POSTaggerME tagger = new POSTaggerME(model);

     //Generating tags
      String[] tags = tagger.tag(tokens);

     //Instantiating POSSample class
      POSSample sample = new POSSample(tokens, tags);
      System.out.println(sample.toString());

     //Monitoring the performance of POS tagger
      PerformanceMonitor perfMon = new PerformanceMonitor(System.err, "sent");
      perfMon.start();
      perfMon.incrementCounter();
      perfMon.stopAndPrintFinalResult();
   }
}

次のコマンドを使用して、コマンドプロンプトから保存したJavaファイルをコンパイルして実行します- 

javac PosTaggerExample.java
java PosTaggerExample

実行時に、上記のプログラムは指定されたテキストを読み取り、これらの文の品詞にタグを付けて表示します。 さらに、POSタガーのパフォーマンスも監視して表示します。 

Hi_NNP welcome_JJ to_TO finddevguides_VB
Average: 0.0 sent/s
Total: 1 sent
Runtime: 0.0s

POSタガー確率

*POSTaggerME* クラスの* probs（）*メソッドは、最近タグ付けされた文の各タグの確率を見つけるために使用されます。
//Getting the probabilities of the recent calls to tokenizePos() method
double[] probs = detector.getSentenceProbabilities();

以下は、最後のタグ付き文の各タグの確率を表示するプログラムです。 このプログラムを PosTaggerProbs.java という名前のファイルに保存します。 

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

import opennlp.tools.postag.POSModel;
import opennlp.tools.postag.POSSample;
import opennlp.tools.postag.POSTaggerME;
import opennlp.tools.tokenize.WhitespaceTokenizer;

public class PosTaggerProbs {

   public static void main(String args[]) throws Exception{

     //Loading Parts of speech-maxent model
      InputStream inputStream = new FileInputStream("C:/OpenNLP_mdl/en-pos-maxent.bin");
      POSModel model = new POSModel(inputStream);

     //Creating an object of WhitespaceTokenizer class
      WhitespaceTokenizer whitespaceTokenizer= WhitespaceTokenizer.INSTANCE;

     //Tokenizing the sentence
      String sentence = "Hi welcome to finddevguides";
      String[] tokens = whitespaceTokenizer.tokenize(sentence);

     //Instantiating POSTaggerME class
      POSTaggerME tagger = new POSTaggerME(model);

     //Generating tags
      String[] tags = tagger.tag(tokens);

     //Instantiating the POSSample class
      POSSample sample = new POSSample(tokens, tags);
      System.out.println(sample.toString());

     //Probabilities for each tag of the last tagged sentence.
      double [] probs = tagger.probs();
      System.out.println("  ");

     //Printing the probabilities
      for(int i = 0; i<probs.length; i++)
         System.out.println(probs[i]);
   }
}

次のコマンドを使用して、コマンドプロンプトから保存したJavaファイルをコンパイルして実行します- 

javac TokenizerMEProbs.java
java TokenizerMEProbs

実行時に、上記のプログラムは指定された生のテキストを読み取り、トークン内の各トークンの品詞にタグを付けて表示します。 さらに、以下に示すように、特定の文の品詞ごとの確率も表示します。 

Hi_NNP welcome_JJ to_TO finddevguides_VB
0.6416834779738033
0.42983612874819177
0.8584513635863117
0.4394784478206072

OpenNLP-文の解析

OpenNLP APIを使用して、指定された文を解析できます。 この章では、OpenNLP APIを使用して生テキストを解析する方法について説明します。

OpenNLPライブラリを使用した生テキストの解析

文を検出するために、OpenNLPは事前定義モデル、 en-parserchunking.bin という名前のファイルを使用します。 これは、指定された生テキストを解析するように訓練された事前定義モデルです。 

*opennlp.tools.Parser* パッケージの *Parser* クラスは解析構成要素を保持するために使用され、 *opennlp.tools.cmdline.parser* パッケージの *ParserTool* クラスはコンテンツを解析するために使用されます。

以下は、 ParserTool クラスを使用して、指定された生テキストを解析するプログラムを作成するために従うべき手順です。

ステップ1：モデルの読み込み

テキストを解析するためのモデルは、パッケージ opennlp.tools.parser に属する ParserModel という名前のクラスで表されます。

トークナイザーモデルをロードするには-

  • モデルの InputStream オブジェクトを作成します（FileInputStreamをインスタンス化し、モデルのパスをString形式でコンストラクターに渡します）。
  • 次のコードブロックに示すように、 ParserModel クラスをインスタンス化し、モデルの InputStream （オブジェクト）をコンストラクターにパラメーターとして渡します。
//Loading parser model
InputStream inputStream = new FileInputStream(".../en-parserchunking.bin");
ParserModel model = new ParserModel(inputStream);

ステップ2：Parserクラスのオブジェクトを作成する

パッケージ opennlp.tools.parser の Parser クラスは、解析構成要素を保持するためのデータ構造を表します。 ParserFactory クラスのstatic * create（）*メソッドを使用して、このクラスのオブジェクトを作成できます。

以下に示すように、前の手順で作成したモデルオブジェクトを渡すことにより、 ParserFactory の* create（）*メソッドを呼び出します- 

//Creating a parser Parser parser = ParserFactory.create(model);

ステップ3：文を解析する

*ParserTool* クラスの* parseLine（）*メソッドは、OpenNLPの生テキストを解析するために使用されます。 このメソッドは受け入れます-
  • 解析するテキストを表す文字列変数。
  • パーサーオブジェクト。
  • 実行される解析の数を表す整数。

文に次のパラメーターを渡すことにより、このメソッドを呼び出します。前のステップで作成された解析オブジェクト、および実行される解析の必要数を表す整数。 

//Parsing the sentence
String sentence = "finddevguides is the largest tutorial library.";
Parse topParses[] = ParserTool.parseLine(sentence, parser, 1);

例

以下は、指定された生のテキストを解析するプログラムです。 このプログラムを ParserExample.java という名前のファイルに保存します。 

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

import opennlp.tools.cmdline.parser.ParserTool;
import opennlp.tools.parser.Parse;
import opennlp.tools.parser.Parser;
import opennlp.tools.parser.ParserFactory;
import opennlp.tools.parser.ParserModel;

public class ParserExample {

   public static void main(String args[]) throws Exception{
     //Loading parser model
      InputStream inputStream = new FileInputStream(".../en-parserchunking.bin");
      ParserModel model = new ParserModel(inputStream);

     //Creating a parser
      Parser parser = ParserFactory.create(model);

     //Parsing the sentence
      String sentence = "finddevguides is the largest tutorial library.";
      Parse topParses[] = ParserTool.parseLine(sentence, parser, 1);

      for (Parse p : topParses)
         p.show();
   }
}

次のコマンドを使用して、コマンドプロンプトから保存したJavaファイルをコンパイルして実行します- 

javac ParserExample.java
java ParserExample

実行時に、上記のプログラムは、指定された生のテキストを読み取り、それを解析し、次の出力を表示します- 

(TOP (S (NP (NN finddevguides)) (VP (VBZ is) (NP (DT the) (JJS largest) (NN
   tutorial) (NN library.)))))

OpenNLP-チャンキング文

文のチャンク化とは、文を単語グループや動詞グループなどの単語の一部に分割/分割することを指します。

OpenNLPを使用した文のチャンク化

文を検出するために、OpenNLPは en-chunker.bin という名前のファイルというモデルを使用します。 これは、指定された生テキストの文をチャンクするように訓練された事前定義モデルです。 

*opennlp.tools.chunker* パッケージには、名詞句チャンクなどの非再帰的な構文注釈を見つけるために使用されるクラスとインターフェースが含まれています。
*ChunkerME* クラスの* chunk（）*メソッドを使用して文をチャンクできます。 このメソッドは、文のトークンとPOSタグをパラメーターとして受け入れます。 したがって、チャンクのプロセスを開始する前に、まず文をトークン化し、そのPOSタグのパーツを生成する必要があります。

OpenNLPライブラリを使用して文をチャンクするには、する必要があります-

  • 文をトークン化します。
  • そのためのPOSタグを生成します。
  • ChunkerModel クラスを使用して en-chunker.bin モデルを読み込みます
  • ChunkerME クラスをインスタンス化します。
  • このクラスの* chunk（）*メソッドを使用して文をチャンクします。

以下は、与えられた生のテキストから文をチャンクするプログラムを書くために従うべきステップです。

ステップ1：文のトークン化

次のコードブロックに示すように、 whitespaceTokenizer クラスの* tokenize（）*メソッドを使用して文をトークン化します。 

//Tokenizing the sentence
String sentence = "Hi welcome to finddevguides";
WhitespaceTokenizer whitespaceTokenizer= WhitespaceTokenizer.INSTANCE;
String[] tokens = whitespaceTokenizer.tokenize(sentence);

ステップ2：POSタグを生成する

次のコードブロックに示すように、 POSTaggerME クラスの* tag（）*メソッドを使用して、文のPOSタグを生成します。 

//Generating the POS tags
File file = new File("C:/OpenNLP_models/en-pos-maxent.bin");
POSModel model = new POSModelLoader().load(file);
//Constructing the tagger
POSTaggerME tagger = new POSTaggerME(model);
//Generating tags from the tokens
String[] tags = tagger.tag(tokens);

ステップ3：モデルの読み込み

文をチャンク化するモデルは、 ChunkerModel という名前のクラスで表されます。このクラスは、パッケージ opennlp.tools.chunker に属します。

文検出モデルをロードするには-

  • モデルの InputStream オブジェクトを作成します（FileInputStreamをインスタンス化し、モデルのパスをString形式でコンストラクターに渡します）。
  • 次のコードブロックに示すように、 ChunkerModel クラスをインスタンス化し、モデルの InputStream （オブジェクト）をコンストラクターにパラメーターとして渡します-
//Loading the chunker model
InputStream inputStream = new FileInputStream("C:/OpenNLP_models/en-chunker.bin");
ChunkerModel chunkerModel = new ChunkerModel(inputStream);

ステップ4：chunkerMEクラスのインスタンス化

パッケージ opennlp.tools.chunker の chunkerME クラスには、文をチャンクするメソッドが含まれています。 これは、最大エントロピーベースのチャンカーです。

このクラスをインスタンス化し、前の手順で作成したモデルオブジェクトを渡します。 

//Instantiate the ChunkerME class
ChunkerME chunkerME = new ChunkerME(chunkerModel);

ステップ5：文のチャンク化

*ChunkerME* クラスの* chunk（）*メソッドを使用して、渡された生テキストの文をチャンクします。 このメソッドは、トークンとタグを表す2つの文字列配列をパラメーターとして受け入れます。

前の手順で作成したトークン配列とタグ配列をパラメーターとして渡すことにより、このメソッドを呼び出します。 

//Generating the chunks
String result[] = chunkerME.chunk(tokens, tags);

例

以下は、指定された生テキストの文をチャンクするプログラムです。 このプログラムを ChunkerExample.java という名前のファイルに保存します。 

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

import opennlp.tools.chunker.ChunkerME;
import opennlp.tools.chunker.ChunkerModel;
import opennlp.tools.cmdline.postag.POSModelLoader;
import opennlp.tools.postag.POSModel;
import opennlp.tools.postag.POSTaggerME;
import opennlp.tools.tokenize.WhitespaceTokenizer;

public class ChunkerExample{

   public static void main(String args[]) throws IOException {
     //Tokenizing the sentence
      String sentence = "Hi welcome to finddevguides";
      WhitespaceTokenizer whitespaceTokenizer= WhitespaceTokenizer.INSTANCE;
      String[] tokens = whitespaceTokenizer.tokenize(sentence);

     //Generating the POS tags
     //Load the parts of speech model
      File file = new File("C:/OpenNLP_models/en-pos-maxent.bin");
      POSModel model = new POSModelLoader().load(file);

     //Constructing the tagger
      POSTaggerME tagger = new POSTaggerME(model);

     //Generating tags from the tokens
      String[] tags = tagger.tag(tokens);

     //Loading the chunker model
      InputStream inputStream = new
         FileInputStream("C:/OpenNLP_models/en-chunker.bin");
      ChunkerModel chunkerModel = new ChunkerModel(inputStream);

     //Instantiate the ChunkerME class
      ChunkerME chunkerME = new ChunkerME(chunkerModel);

     //Generating the chunks
      String result[] = chunkerME.chunk(tokens, tags);

      for (String s : result)
         System.out.println(s);
   }
}

次のコマンドを使用して、コマンドプロンプトから保存されたJavaファイルをコンパイルして実行します- 

javac ChunkerExample.java
java ChunkerExample

実行時に、上記のプログラムは指定された文字列を読み取り、その中の文をチャンクし、以下に示すように表示します。 

Loading POS Tagger model ... done (1.040s)
B-NP
I-NP
B-VP
I-VP

トークンの位置の検出

*ChunkerME* クラスの* chunkAsSpans（）*メソッドを使用して、チャンクの位置またはスパンを検出することもできます。 このメソッドは、Span型のオブジェクトの配列を返します。 *opennlp.tools.util* パッケージのSpanという名前のクラスは、セットの *start* および *end* 整数を格納するために使用されます。

次のコードブロックに示すように、* chunkAsSpans（）*メソッドによって返されたスパンをSpan配列に格納して印刷できます。 

//Generating the tagged chunk spans
Span[] span = chunkerME.chunkAsSpans(tokens, tags);

for (Span s : span)
   System.out.println(s.toString());

例

以下は、指定された生テキスト内の文を検出するプログラムです。 このプログラムを ChunkerSpansEample.java という名前のファイルに保存します。 

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

import opennlp.tools.chunker.ChunkerME;
import opennlp.tools.chunker.ChunkerModel;
import opennlp.tools.cmdline.postag.POSModelLoader;
import opennlp.tools.postag.POSModel;
import opennlp.tools.postag.POSTaggerME;
import opennlp.tools.tokenize.WhitespaceTokenizer;
import opennlp.tools.util.Span;

public class ChunkerSpansEample{

   public static void main(String args[]) throws IOException {
     //Load the parts of speech model
      File file = new File("C:/OpenNLP_models/en-pos-maxent.bin");
      POSModel model = new POSModelLoader().load(file);

     //Constructing the tagger
      POSTaggerME tagger = new POSTaggerME(model);

     //Tokenizing the sentence
      String sentence = "Hi welcome to finddevguides";
      WhitespaceTokenizer whitespaceTokenizer= WhitespaceTokenizer.INSTANCE;
      String[] tokens = whitespaceTokenizer.tokenize(sentence);

     //Generating tags from the tokens
      String[] tags = tagger.tag(tokens);

     //Loading the chunker model
      InputStream inputStream = new
         FileInputStream("C:/OpenNLP_models/en-chunker.bin");
      ChunkerModel chunkerModel = new ChunkerModel(inputStream);
      ChunkerME chunkerME = new ChunkerME(chunkerModel);

     //Generating the tagged chunk spans
      Span[] span = chunkerME.chunkAsSpans(tokens, tags);

      for (Span s : span)
         System.out.println(s.toString());
   }
}

次のコマンドを使用して、コマンドプロンプトから保存したJavaファイルをコンパイルして実行します- 

javac ChunkerSpansEample.java
java ChunkerSpansEample

実行すると、上記のプログラムは、指定された文字列とその中のチャンクのスパンを読み取り、次の出力を表示します- 

Loading POS Tagger model ... done (1.059s)
[0..2) NP
[2..4) VP

チャンカー確率検出

*ChunkerME* クラスの* probs（）*メソッドは、最後にデコードされたシーケンスの確率を返します。
//Getting the probabilities of the last decoded sequence
double[] probs = chunkerME.probs();

以下は、 chunker によって最後にデコードされたシーケンスの確率を出力するプログラムです。 このプログラムを ChunkerProbsExample.java という名前のファイルに保存します。 

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import opennlp.tools.chunker.ChunkerME;
import opennlp.tools.chunker.ChunkerModel;
import opennlp.tools.cmdline.postag.POSModelLoader;
import opennlp.tools.postag.POSModel;
import opennlp.tools.postag.POSTaggerME;
import opennlp.tools.tokenize.WhitespaceTokenizer;

public class ChunkerProbsExample{

   public static void main(String args[]) throws IOException {
     //Load the parts of speech model
      File file = new File("C:/OpenNLP_models/en-pos-maxent.bin");
      POSModel model = new POSModelLoader().load(file);

     //Constructing the tagger
      POSTaggerME tagger = new POSTaggerME(model);

     //Tokenizing the sentence
      String sentence = "Hi welcome to finddevguides";
      WhitespaceTokenizer whitespaceTokenizer= WhitespaceTokenizer.INSTANCE;
      String[] tokens = whitespaceTokenizer.tokenize(sentence);

     //Generating tags from the tokens
      String[] tags = tagger.tag(tokens);

     //Loading the chunker model
      InputStream inputStream = new
         FileInputStream("C:/OpenNLP_models/en-chunker.bin");
      ChunkerModel cModel = new ChunkerModel(inputStream);
      ChunkerME chunkerME = new ChunkerME(cModel);

     //Generating the chunk tags
      chunkerME.chunk(tokens, tags);

     //Getting the probabilities of the last decoded sequence
      double[] probs = chunkerME.probs();
      for(int i = 0; i<probs.length; i++)
         System.out.println(probs[i]);
   }
}

次のコマンドを使用して、コマンドプロンプトから保存したJavaファイルをコンパイルして実行します- 

javac ChunkerProbsExample.java
java ChunkerProbsExample

実行時に、上記のプログラムは指定された文字列を読み取り、チャンクし、最後にデコードされたシーケンスの確率を出力します。 

0.9592746040797778
0.6883933131241501
0.8830563473996004
0.8951150529746051

OpenNLP-コマンドラインインターフェース

OpenNLPは、コマンドラインからさまざまな操作を実行するためのコマンドラインインターフェイス（CLI）を提供します。 この章では、OpenNLPコマンドラインインターフェイスの使用方法を示すためにいくつかの例を取り上げます。

トークン化

input.txt

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

構文

 > opennlp TokenizerME path_for_models../en-token.bin <inputfile..> outputfile..

コマンド

C:\> opennlp TokenizerME C:\OpenNLP_models/en-token.bin <input.txt >output.txt

出力

Loading Tokenizer model ... done (0.207s)
Average: 214.3 sent/s
Total: 3 sent
Runtime: 0.014s

output.txt

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

文検出

input.txt

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

構文

 > opennlp SentenceDetector path_for_models../en-token.bin <inputfile..> outputfile..

コマンド

C:\> opennlp SentenceDetector C:\OpenNLP_models/en-sent.bin <input.txt > output_sendet.txt

出力

Loading Sentence Detector model ... done (0.067s)

Average: 750.0 sent/s
Total: 3 sent
Runtime: 0.004s

Output_sendet.txt

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

名前付きエンティティの認識

input.txt

<START:person> <START:person> Mike <END> <END> is senior programming manager and
<START:person> Rama <END> is a clerk both are working at finddevguides

構文

 > opennlp TokenNameFinder path_for_models../en-token.bin <inputfile..

コマンド

C:\>opennlp TokenNameFinder C:\OpenNLP_models\en-ner-person.bin <input_namefinder.txt

出力

Loading Token Name Finder model ... done (0.730s)
<START:person> <START:person> Mike <END> <END> is senior programming manager and
<START:person> Rama <END> is a clerk both are working at finddevguides
Average: 55.6 sent/s
Total: 1 sent
Runtime: 0.018s

品詞タグ付け

Input.txt

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

構文

 > opennlp POSTagger path_for_models../en-token.bin <inputfile..

コマンド

C:\>opennlp POSTagger C:\OpenNLP_models/en-pos-maxent.bin < input.txt

出力

Loading POS Tagger model ... done (1.315s)
Hi._NNP How_WRB are_VBP you?_JJ Welcome_NNP to_TO finddevguides._NNP We_PRP
provide_VBP free_JJ tutorials_NNS on_IN various_JJ technologies_NNS

Average: 66.7 sent/s
Total: 1 sent
Runtime: 0.015s
「https://www.finddevguides.com/index.php?title=Opennlp-quick-guide&oldid=79164」から取得
Powered by MediaWiki