OpenNLP - Reconocimiento de entidad nombrada

El proceso de encontrar nombres, personas, lugares y otras entidades de un texto dado se conoce como Named Eentidad Rreconocimiento (NER). En este capítulo, discutiremos cómo realizar NER a través del programa Java usando la biblioteca OpenNLP.

Reconocimiento de entidad nombrada usando PNL abierto

Para realizar varias tareas de NER, OpenNLP utiliza diferentes modelos predefinidos, a saber, en-nerdate.bn, en-ner-location.bin, en-ner-organization.bin, en-ner-person.bin y en-ner-time. compartimiento. Todos estos archivos son modelos predefinidos que están entrenados para detectar las entidades respectivas en un texto sin formato dado.

los opennlp.tools.namefindEl paquete contiene las clases y las interfaces que se utilizan para realizar la tarea NER. Para realizar la tarea NER utilizando la biblioteca OpenNLP, debe:

• Cargue el modelo respectivo usando el TokenNameFinderModel clase.

• Instancia del NameFinder clase.

• Busque los nombres e imprímalos.

A continuación se muestran los pasos a seguir para escribir un programa que detecte las entidades de nombre de un texto en bruto dado.

Paso 1: carga del modelo

El modelo para la detección de oraciones está representado por la clase denominada TokenNameFinderModel, que pertenece al paquete opennlp.tools.namefind.

Para cargar un modelo NER:

• Crear un InputStream objeto del modelo (Cree una instancia de FileInputStream y pase la ruta del modelo NER apropiado en formato String a su constructor).

• Instancia del TokenNameFinderModel clase y pasar el InputStream (objeto) del modelo como parámetro para su constructor, como se muestra en el siguiente bloque de código.

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

Paso 2: instanciar la clase NameFinderME

los NameFinderME clase del paquete opennlp.tools.namefindcontiene métodos para realizar las tareas NER. Esta clase usa el modelo de máxima entropía para encontrar las entidades nombradas en el texto sin formato dado.

Cree una instancia de esta clase y pase el objeto modelo creado en el paso anterior como se muestra a continuación:

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

Paso 3: encontrar los nombres en la oración

los find() método del NameFinderMELa clase se utiliza para detectar los nombres en el texto sin formato que se le pasa. Este método acepta una variable String como parámetro.

Invoque este método pasando el formato de cadena de la oración a este método.

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

Paso 4: imprimir los intervalos de los nombres en la oración

los find() método del NameFinderMELa clase 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 find() en la matriz Span e imprímalos, como se muestra en el siguiente bloque de código.

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

NER Example

A continuación se muestra el programa que lee la oración dada y reconoce los intervalos de los nombres de las personas en ella. Guarde este programa en un archivo con el nombreNameFinderME_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());    
   }    
}

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

javac NameFinderME_Example.java 
java NameFinderME_Example

Al ejecutarse, el programa anterior lee la cadena dada (texto sin formato), detecta los nombres de las personas en él y muestra sus posiciones (intervalos), como se muestra a continuación.

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

Nombres junto con sus posiciones

los substring() El método de la clase String acepta el begin y el end offsetsy devuelve la cadena respectiva. Podemos usar este método para imprimir los nombres y sus intervalos (posiciones) juntos, como se muestra en el siguiente bloque de código.

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

A continuación se muestra el programa para detectar los nombres del texto sin formato dado y mostrarlos junto con sus posiciones. Guarde este programa en un archivo con el nombreNameFinderSentences.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()]);      
   }    
}

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

javac NameFinderSentences.java 
java NameFinderSentences

Al ejecutarse, el programa anterior lee la Cadena dada (texto sin formato), detecta los nombres de las personas en él y muestra sus posiciones (intervalos) como se muestra a continuación.

[0..1) person  Mike

Encontrar los nombres de la ubicación

Al cargar varios modelos, puede detectar varias entidades con nombre. A continuación se muestra un programa Java que carga elen-ner-location.binmodela y detecta los nombres de ubicación en la oración dada. Guarde este programa en un archivo con el nombreLocationFinder.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 = "Tutorialspoint 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()]); 
   }    
}

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

javac LocationFinder.java 
java LocationFinder

Al ejecutarse, el programa anterior lee la cadena dada (texto sin formato), detecta los nombres de las personas en él y muestra sus posiciones (intervalos), como se muestra a continuación.

[4..5) location  Hyderabad

Probabilidad de NameFinder

los probs()método del NameFinderME La clase se usa para obtener las probabilidades de la última secuencia decodificada.

double[] probs = nameFinder.probs();

A continuación se muestra el programa para imprimir las probabilidades. Guarde este programa en un archivo con el nombreTokenizerMEProbs.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]);          
   } 
}

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

javac TokenizerMEProbs.java 
java TokenizerMEProbs

Al ejecutarse, el programa anterior lee la Cadena dada, tokeniza las oraciones y las imprime. Además, también devuelve las probabilidades de la última secuencia decodificada, como se muestra a continuación.

[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