OpenNLP - Fragmentación de frases

Fragmentar una oración se refiere a dividir una oración en partes de palabras, como grupos de palabras y grupos de verbos.

Fragmentar una oración usando OpenNLP

Para detectar las oraciones, OpenNLP usa un modelo, un archivo llamado en-chunker.bin. Este es un modelo predefinido que está entrenado para fragmentar las oraciones en el texto sin formato dado.

los opennlp.tools.chunker El paquete contiene las clases e interfaces que se utilizan para encontrar anotaciones sintácticas no recursivas, como fragmentos de frases nominales.

Puedes fragmentar una oración usando el método chunk() del ChunkerMEclase. Este método acepta tokens de una oración y etiquetas POS como parámetros. Por lo tanto, antes de comenzar el proceso de fragmentación, primero debe Tokenizar la oración y generar las etiquetas POS de las partes de la misma.

Para fragmentar una oración usando la biblioteca OpenNLP, necesita:

Tokeniza la oración.
Genere etiquetas POS para ello.
Carga el en-chunker.bin modelo usando el ChunkerModel clase
Instancia del ChunkerME clase.
Divida las oraciones usando el chunk() método de esta clase.

Los siguientes son los pasos que se deben seguir para escribir un programa para fragmentar oraciones a partir del texto en bruto dado.

Paso 1: Tokenizar la oración

Tokenize las oraciones usando el tokenize() método del whitespaceTokenizer class, como se muestra en el siguiente bloque de código.

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

Paso 2: Generar las etiquetas POS

Genere las etiquetas POS de la oración usando el tag() método del POSTaggerME class, como se muestra en el siguiente bloque de código.

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

Paso 3: carga del modelo

El modelo para fragmentar una oración está representado por la clase denominada ChunkerModel, que pertenece al paquete opennlp.tools.chunker.

Para cargar un modelo de detección de frases:

Crear un InputStream objeto del modelo (Cree una instancia de FileInputStream y pase la ruta del modelo en formato String a su constructor).
Instancia del ChunkerModel clase y pasar el InputStream (objeto) del modelo como un parámetro para su constructor, como se muestra en el siguiente bloque de código:

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

Paso 4: instanciar la clase chunkerME

los chunkerME clase del paquete opennlp.tools.chunkercontiene métodos para fragmentar las oraciones. Este es un fragmento basado en la máxima entropía.

Cree una instancia de esta clase y pase el objeto modelo creado en el paso anterior.

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

Paso 5: fragmentar la oración

los chunk() método del ChunkerMEclass se usa para fragmentar las oraciones en el texto sin formato que se le pasa. Este método acepta dos matrices de cadenas que representan tokens y etiquetas, como parámetros.

Invoque este método pasando la matriz de tokens y la matriz de etiquetas creada en los pasos anteriores como parámetros.

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

Example

A continuación se muestra el programa para fragmentar las oraciones en el texto sin formato dado. Guarde este programa en un archivo con el nombreChunkerExample.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);         
   }    
}

Compile y ejecute el archivo Java guardado desde el símbolo del sistema usando el siguiente comando:

javac ChunkerExample.java 
java ChunkerExample

Al ejecutarse, el programa anterior lee la cadena dada y fragmenta las oraciones en ella, y las muestra como se muestra a continuación.

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

Detectando las posiciones de los tokens

También podemos detectar las posiciones o tramos de los trozos usando el chunkAsSpans() método del ChunkerMEclase. Este método devuelve una matriz de objetos del tipo Span. La clase denominada Span delopennlp.tools.util El paquete se utiliza para almacenar el start y end entero de conjuntos.

Puede almacenar los intervalos devueltos por el chunkAsSpans() en la matriz Span e imprímalos, como se muestra en el siguiente bloque de código.

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

Example

A continuación se muestra el programa que detecta las oraciones en el texto sin formato dado. Guarde este programa en un archivo con el nombreChunkerSpansEample.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());  
   }    
}

Compile y ejecute el archivo Java guardado desde el símbolo del sistema utilizando los siguientes comandos:

javac ChunkerSpansEample.java 
java ChunkerSpansEample

Al ejecutarse, el programa anterior lee la cadena dada y los tramos de los fragmentos que contiene, y muestra la siguiente salida:

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

Detección de probabilidad de fragmentos

los probs() método del ChunkerME class devuelve las probabilidades de la última secuencia decodificada.

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

A continuación se muestra el programa para imprimir las probabilidades de la última secuencia decodificada por el chunker. Guarde este programa en un archivo con el nombreChunkerProbsExample.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]);       
   }    
}

Compile y ejecute el archivo Java guardado desde el símbolo del sistema utilizando los siguientes comandos:

javac ChunkerProbsExample.java 
java ChunkerProbsExample

Al ejecutarse, el programa anterior lee la cadena dada, la fragmenta e imprime las probabilidades de la última secuencia decodificada.

0.9592746040797778 
0.6883933131241501 
0.8830563473996004 
0.8951150529746051

↰ Previous page Next page ↱