OpenNLP - Chunking Sätze

Das Aufteilen eines Satzes bezieht sich auf das Brechen / Teilen eines Satzes in Wortteile wie Wortgruppen und Verbgruppen.

Chunking eines Satzes mit OpenNLP

Um die Sätze zu erkennen, verwendet OpenNLP ein Modell, eine Datei mit dem Namen en-chunker.bin. Dies ist ein vordefiniertes Modell, das darauf trainiert ist, die Sätze im angegebenen Rohtext zu zerlegen.

Das opennlp.tools.chunker Das Paket enthält die Klassen und Schnittstellen, die zum Auffinden nicht rekursiver syntaktischer Annotationen verwendet werden, z.

Mit der Methode können Sie einen Satz aufteilen chunk() des ChunkerMEKlasse. Diese Methode akzeptiert Token eines Satzes und POS-Tags als Parameter. Bevor Sie mit dem Chunking beginnen, müssen Sie daher zunächst den Satz tokenisieren und die Teile-POS-Tags daraus generieren.

Um einen Satz mit der OpenNLP-Bibliothek zu zerlegen, müssen Sie -

  • Tokenisieren Sie den Satz.

  • Generieren Sie dafür POS-Tags.

  • Laden Sie die en-chunker.bin Modell mit dem ChunkerModel Klasse

  • Instanziieren Sie die ChunkerME Klasse.

  • Chunk die Sätze mit dem chunk() Methode dieser Klasse.

Im Folgenden sind die Schritte aufgeführt, die ausgeführt werden müssen, um ein Programm zu schreiben, das Sätze aus dem angegebenen Rohtext aufteilt.

Schritt 1: Tokenisieren des Satzes

Tokenisieren Sie die Sätze mit dem tokenize() Methode der whitespaceTokenizer Klasse, wie im folgenden Codeblock gezeigt.

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

Schritt 2: Generieren der POS-Tags

Generieren Sie die POS-Tags des Satzes mit dem tag() Methode der POSTaggerME Klasse, wie im folgenden Codeblock gezeigt.

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

Schritt 3: Laden des Modells

Das Modell zum Aufteilen eines Satzes wird durch die genannte Klasse dargestellt ChunkerModel, die zum Paket gehört opennlp.tools.chunker.

So laden Sie ein Satzerkennungsmodell:

  • Erstelle ein InputStream Objekt des Modells (Instanziieren Sie den FileInputStream und übergeben Sie den Pfad des Modells im String-Format an seinen Konstruktor).

  • Instanziieren Sie die ChunkerModel Klasse und bestehen die InputStream (Objekt) des Modells als Parameter für seinen Konstruktor, wie im folgenden Codeblock gezeigt -

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

Schritt 4: Instanziieren der chunkerME-Klasse

Das chunkerME Klasse des Pakets opennlp.tools.chunkerenthält Methoden zum Aufteilen der Sätze. Dies ist ein Chunker auf der Basis maximaler Entropie.

Instanziieren Sie diese Klasse und übergeben Sie das im vorherigen Schritt erstellte Modellobjekt.

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

Schritt 5: Den Satz aufteilen

Das chunk() Methode der ChunkerMEKlasse wird verwendet, um die Sätze in dem an sie übergebenen Rohtext zu zerlegen. Diese Methode akzeptiert zwei String-Arrays, die Token und Tags darstellen, als Parameter.

Rufen Sie diese Methode auf, indem Sie das in den vorherigen Schritten erstellte Token-Array und Tag-Array als Parameter übergeben.

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

Example

Es folgt das Programm zum Aufteilen der Sätze in den angegebenen Rohtext. Speichern Sie dieses Programm in einer Datei mit dem NamenChunkerExample.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 Tutorialspoint";       
      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);         
   }    
}

Kompilieren Sie die gespeicherte Java-Datei und führen Sie sie an der Eingabeaufforderung mit dem folgenden Befehl aus:

javac ChunkerExample.java 
java ChunkerExample

Bei der Ausführung liest das obige Programm den angegebenen String, zerlegt die darin enthaltenen Sätze und zeigt sie wie unten gezeigt an.

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

Erkennen der Positionen der Token

Wir können auch die Positionen oder Spannweiten der Chunks mithilfe von erkennen chunkAsSpans() Methode der ChunkerMEKlasse. Diese Methode gibt ein Array von Objekten vom Typ Span zurück. Die Klasse namens Span of theopennlp.tools.util Paket wird verwendet, um die zu speichern start und end Ganzzahl von Mengen.

Sie können die vom chunkAsSpans() Methode im Span-Array und drucken Sie sie aus, wie im folgenden Codeblock gezeigt.

//Generating the tagged chunk spans 
Span[] span = chunkerME.chunkAsSpans(tokens, tags); 
       
for (Span s : span) 
   System.out.println(s.toString());

Example

Es folgt das Programm, das die Sätze im angegebenen Rohtext erkennt. Speichern Sie dieses Programm in einer Datei mit dem NamenChunkerSpansEample.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 Tutorialspoint";       
      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());  
   }    
}

Kompilieren Sie die gespeicherte Java-Datei und führen Sie sie an der Eingabeaufforderung mit den folgenden Befehlen aus:

javac ChunkerSpansEample.java 
java ChunkerSpansEample

Bei der Ausführung liest das obige Programm den angegebenen String und die angegebenen Bereiche der darin enthaltenen Chunks und zeigt die folgende Ausgabe an:

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

Chunker-Wahrscheinlichkeitserkennung

Das probs() Methode der ChunkerME Klasse gibt die Wahrscheinlichkeiten der zuletzt dekodierten Sequenz zurück.

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

Es folgt das Programm zum Drucken der Wahrscheinlichkeiten der zuletzt decodierten Sequenz durch die chunker. Speichern Sie dieses Programm in einer Datei mit dem NamenChunkerProbsExample.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 Tutorialspoint";       
      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]);       
   }    
}

Kompilieren Sie die gespeicherte Java-Datei und führen Sie sie an der Eingabeaufforderung mit den folgenden Befehlen aus:

javac ChunkerProbsExample.java 
java ChunkerProbsExample

Bei der Ausführung liest das obige Programm den angegebenen String, zerlegt ihn und gibt die Wahrscheinlichkeiten der zuletzt decodierten Sequenz aus.

0.9592746040797778 
0.6883933131241501 
0.8830563473996004 
0.8951150529746051
ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved