OpenNLP - Guía rápida

NLP es un conjunto de herramientas que se utilizan para obtener información útil y significativa de fuentes de lenguaje natural, como páginas web y documentos de texto.

¿Qué es Open NLP?

apache OpenNLPes una biblioteca Java de código abierto que se utiliza para procesar texto en lenguaje natural. Puede crear un servicio de procesamiento de texto eficiente utilizando esta biblioteca.

OpenNLP proporciona servicios tales como tokenización, segmentación de oraciones, etiquetado de parte del discurso, extracción de entidad con nombre, fragmentación, análisis y resolución de co-referencia, etc.

Características de OpenNLP

Las siguientes son las características notables de OpenNLP:

  • Named Entity Recognition (NER) - Open NLP admite NER, con el cual puede extraer nombres de ubicaciones, personas y cosas incluso mientras procesa consultas.

  • Summarize - Usando el summarize característica, puede resumir párrafos, artículos, documentos o su colección en PNL.

  • Searching - En OpenNLP, una determinada cadena de búsqueda o sus sinónimos se pueden identificar en un texto determinado, aunque la palabra dada esté alterada o mal escrita.

  • Tagging (POS) - El etiquetado en PNL se utiliza para dividir el texto en varios elementos gramaticales para su posterior análisis.

  • Translation - En PNL, Translation ayuda a traducir un idioma a otro.

  • Information grouping - Esta opción en PNL agrupa la información textual en el contenido del documento, al igual que las partes gramaticales.

  • Natural Language Generation - Se utiliza para generar información a partir de una base de datos y automatizar los informes de información como análisis meteorológico o informes médicos.

  • Feedback Analysis - Como su nombre lo indica, la PNL recopila varios tipos de comentarios de las personas, con respecto a los productos, para analizar qué tan bien el producto tiene éxito en ganarse su corazón.

  • Speech recognition - Aunque es difícil analizar el habla humana, la PNL tiene algunas funciones integradas para este requisito.

API abierta de PNL

La biblioteca Apache OpenNLP proporciona clases e interfaces para realizar diversas tareas de procesamiento del lenguaje natural, como detección de oraciones, tokenización, búsqueda de un nombre, etiquetado de las partes del discurso, fragmentación de una oración, análisis, resolución de co-referencia y categorización de documentos.

Además de estas tareas, también podemos entrenar y evaluar nuestros propios modelos para cualquiera de estas tareas.

CLI OpenNLP

Además de la biblioteca, OpenNLP también proporciona una interfaz de línea de comandos (CLI), donde podemos entrenar y evaluar modelos. Discutiremos este tema en detalle en el último capítulo de este tutorial.

Modelos abiertos de PNL

Para realizar varias tareas de PNL, OpenNLP proporciona un conjunto de modelos predefinidos. Este set incluye modelos para diferentes idiomas.

Descargando los modelos

Puede seguir los pasos que se indican a continuación para descargar los modelos predefinidos proporcionados por OpenNLP.

Step 1 - Abra la página de índice de modelos OpenNLP haciendo clic en el siguiente enlace - http://opennlp.sourceforge.net/models-1.5/.

Step 2- Al visitar el enlace dado, verá una lista de componentes de varios idiomas y los enlaces para descargarlos. Aquí puede obtener la lista de todos los modelos predefinidos proporcionados por OpenNLP.

Descarga todos estos modelos a la carpeta C:/OpenNLP_models/>, haciendo clic en sus respectivos enlaces. Todos estos modelos dependen del idioma y, al usarlos, debe asegurarse de que el idioma del modelo coincida con el idioma del texto de entrada.

Historia de OpenNLP

  • En 2010, OpenNLP entró en la incubación de Apache.

  • En 2011, se lanzó Apache OpenNLP 1.5.2 Incubating, y ese mismo año se graduó como un proyecto Apache de alto nivel.

  • En 2015, OpenNLP fue lanzado 1.6.0.

En este capítulo, discutiremos cómo puede configurar el entorno OpenNLP en su sistema. Comencemos con el proceso de instalación.

Instalación de OpenNLP

Los siguientes son los pasos para descargar Apache OpenNLP library en su sistema.

Step 1 - Abra la página de inicio de Apache OpenNLP haciendo clic en el siguiente enlace - https://opennlp.apache.org/.

Step 2 - Ahora, haga clic en el Downloadsenlace. Al hacer clic, se lo dirigirá a una página donde puede encontrar varios espejos que lo redireccionarán al directorio de distribución de Apache Software Foundation.

Step 3- En esta página puede encontrar enlaces para descargar varias distribuciones de Apache. Examínelos, busque la distribución OpenNLP y haga clic en ella.

Step 4 - Al hacer clic, será redirigido al directorio donde puede ver el índice de la distribución de OpenNLP, como se muestra a continuación.

Haga clic en la última versión de las distribuciones disponibles.

Step 5- Cada distribución proporciona archivos fuente y binarios de la biblioteca OpenNLP en varios formatos. Descargue los archivos fuente y binarios,apache-opennlp-1.6.0-bin.zip y apache-opennlp1.6.0-src.zip (para ventanas).

Configuración de la ruta de clases

Después de descargar la biblioteca OpenNLP, debe establecer su ruta al bindirectorio. Suponga que ha descargado la biblioteca OpenNLP en la unidad E de su sistema.

Ahora, siga los pasos que se dan a continuación:

Step 1 - Haga clic derecho en 'Mi PC' y seleccione 'Propiedades'.

Step 2 - Haga clic en el botón 'Variables de entorno' en la pestaña 'Avanzado'.

Step 3 - Seleccione el path variable y haga clic en el Edit , como se muestra en la siguiente captura de pantalla.

Step 4 - En la ventana Editar variable de entorno, haga clic en el New y agregue la ruta para el directorio OpenNLP E:\apache-opennlp-1.6.0\bin y haga clic en el OK , como se muestra en la siguiente captura de pantalla.

Instalación de Eclipse

Puede configurar el entorno de Eclipse para la biblioteca OpenNLP, ya sea configurando el Build path a los archivos JAR o usando pom.xml.

Configuración de la ruta de compilación para los archivos JAR

Siga los pasos que se indican a continuación para instalar OpenNLP en Eclipse:

Step 1 - Asegúrese de tener el entorno Eclipse instalado en su sistema.

Step 2- Abre Eclipse. Haga clic en Archivo → Nuevo → Abrir un nuevo proyecto, como se muestra a continuación.

Step 3 - Obtendrás el New Projectmago. En este asistente, seleccione el proyecto Java y continúe haciendo clic en elNext botón.

Step 4 - A continuación, obtendrá el New Java Project wizard. Aquí, debe crear un nuevo proyecto y hacer clic en elNext botón, como se muestra a continuación.

Step 5 - Después de crear un nuevo proyecto, haga clic derecho sobre él, seleccione Build Path y haga clic en Configure Build Path.

Step 6 - A continuación, obtendrá el Java Build Pathmago. Aquí, haga clic en elAdd External JARs botón, como se muestra a continuación.

Step 7 - Seleccione los archivos jar opennlp-tools-1.6.0.jar y opennlp-uima-1.6.0.jar ubicado en el lib carpeta de apache-opennlp-1.6.0 folder.

Al hacer clic en el Open en la pantalla anterior, los archivos seleccionados se agregarán a su biblioteca.

Al hacer clic OK, agregará con éxito los archivos JAR requeridos al proyecto actual y podrá verificar estas bibliotecas agregadas expandiendo las Bibliotecas referenciadas, como se muestra a continuación.

Usando pom.xml

Convierta el proyecto en un proyecto Maven y agregue el siguiente código a su 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>

En este capítulo, discutiremos sobre las clases y métodos que usaremos en los siguientes capítulos de este tutorial.

Detección de frases

SentenceModel clase

Esta clase representa el modelo predefinido que se utiliza para detectar las oraciones en el texto sin formato dado. Esta clase pertenece al paqueteopennlp.tools.sentdetect.

El constructor de esta clase acepta un InputStream objeto del archivo de modelo del detector de oraciones (en-sent.bin).

SentenceDetectorME clase

Esta clase pertenece al paquete opennlp.tools.sentdetecty contiene métodos para dividir el texto sin procesar en oraciones. Esta clase usa un modelo de entropía máxima para evaluar los caracteres de fin de oración en una cadena para determinar si significan el final de una oración.

A continuación se muestran los métodos importantes de esta clase.

S. No Métodos y descripción
1

sentDetect()

Este método se utiliza para detectar las oraciones en el texto sin formato que se le pasa. Acepta una variable de cadena como parámetro y devuelve una matriz de cadena que contiene las oraciones del texto sin formato dado.

2

sentPosDetect()

Este método se utiliza para detectar las posiciones de las oraciones en el texto dado. Este método acepta una variable de cadena, que representa la oración y devuelve una matriz de objetos del tipoSpan.

La clase nombrada Span del opennlp.tools.util paquete se utiliza para almacenar el número entero inicial y final de conjuntos.

3

getSentenceProbabilities()

Este método devuelve las probabilidades asociadas con las llamadas más recientes a sentDetect() método.

Tokenización

TokenizerModel clase

Esta clase representa el modelo predefinido que se usa para tokenizar la oración dada. Esta clase pertenece al paqueteopennlp.tools.tokenizer.

El constructor de esta clase acepta un InputStream objeto del archivo del modelo de tokenizador (entoken.bin).

Clases

Para realizar la tokenización, la biblioteca OpenNLP proporciona tres clases principales. Las tres clases implementan la interfaz llamadaTokenizer.

S. No Clases y descripción
1

SimpleTokenizer

Esta clase tokeniza el texto sin formato dado utilizando clases de caracteres.

2

WhitespaceTokenizer

Esta clase usa espacios en blanco para tokenizar el texto dado.

3

TokenizerME

Esta clase convierte el texto sin formato en tokens separados. Utiliza la máxima entropía para tomar sus decisiones.

Estas clases contienen los siguientes métodos.

S. No Métodos y descripción
1

tokenize()

Este método se utiliza para convertir en token el texto sin formato. Este método acepta una variable de cadena como parámetro y devuelve una matriz de cadenas (tokens).

2

sentPosDetect()

Este método se utiliza para obtener las posiciones o lapsos de los tokens. Acepta la oración (o) texto sin formato en forma de cadena y devuelve una matriz de objetos del tipoSpan.

Además de los dos métodos anteriores, el TokenizerME la clase tiene el getTokenProbabilities() método.

S. No Métodos y descripción
1

getTokenProbabilities()

Este método se utiliza para obtener las probabilidades asociadas con las llamadas más recientes al tokenizePos() método.

NombreEntidadReconocimiento

TokenNameFinderModel clase

Esta clase representa el modelo predefinido que se usa para encontrar las entidades nombradas en la oración dada. Esta clase pertenece al paqueteopennlp.tools.namefind.

El constructor de esta clase acepta un InputStream objeto del archivo de modelo del buscador de nombres (enner-person.bin).

Clase NameFinderME

La clase pertenece al paquete opennlp.tools.namefindy contiene métodos para realizar las tareas NER. Esta clase usa un modelo de entropía máxima para encontrar las entidades nombradas en el texto sin formato dado.

S. No Métodos y descripción
1

find()

Este método se utiliza para detectar los nombres en el texto sin formato. Acepta una variable String que representa el texto en bruto como parámetro y devuelve una matriz de objetos del tipo Span.

2

probs()

Este método se utiliza para obtener las probabilidades de la última secuencia decodificada.

Encontrar las partes del habla

Clase POSModel

Esta clase representa el modelo predefinido que se utiliza para etiquetar las partes del discurso de la oración dada. Esta clase pertenece al paqueteopennlp.tools.postag.

El constructor de esta clase acepta un InputStream objeto del archivo de modelo pos-tagger (enpos-maxent.bin).

Clase POSTaggerME

Esta clase pertenece al paquete opennlp.tools.postagy se utiliza para predecir las partes gramaticales del texto sin formato dado. Utiliza la máxima entropía para tomar sus decisiones.

S. No Métodos y descripción
1

tag()

Este método se utiliza para asignar la frase de tokens a las etiquetas POS. Este método acepta una matriz de tokens (String) como parámetro y devuelve una etiqueta (matriz).

2

getSentenceProbabilities()

Este método se utiliza para obtener las probabilidades de cada etiqueta de la oración etiquetada recientemente.

Analizando la oración

Clase ParserModel

Esta clase representa el modelo predefinido que se usa para analizar la oración dada. Esta clase pertenece al paqueteopennlp.tools.parser.

El constructor de esta clase acepta un InputStream objeto del archivo de modelo del analizador (en-parserchunking.bin).

Clase Parser Factory

Esta clase pertenece al paquete opennlp.tools.parser y se usa para crear analizadores.

S. No Métodos y descripción
1

create()

Este es un método estático y se usa para crear un objeto analizador. Este método acepta el objeto Filestream del archivo del modelo del analizador.

Clase ParserTool

Esta clase pertenece a la opennlp.tools.cmdline.parser package y, se utiliza para analizar el contenido.

S. No Métodos y descripción
1

parseLine()

Este método del ParserToolLa clase se utiliza para analizar el texto sin formato en OpenNLP. Este método acepta:

  • Una variable de cadena que representa el texto que se va a analizar.
  • Un objeto analizador.
  • Un número entero que representa el número de análisis que se van a realizar.

Fragmentación

Clase ChunkerModel

Esta clase representa el modelo predefinido que se usa para dividir una oración en partes más pequeñas. Esta clase pertenece al paqueteopennlp.tools.chunker.

El constructor de esta clase acepta un InputStream objeto de la chunker archivo de modelo (enchunker.bin).

Clase ChunkerME

Esta clase pertenece al paquete llamado opennlp.tools.chunker y se usa para dividir la oración dada en partes más pequeñas.

S. No Métodos y descripción
1

chunk()

Este método se utiliza para dividir la oración dada en partes más pequeñas. Acepta tokens de una oración yPletras OF Setiquetas peech como parámetros.

2

probs()

Este método devuelve las probabilidades de la última secuencia decodificada.

Al procesar un lenguaje natural, decidir el comienzo y el final de las oraciones es uno de los problemas a abordar. Este proceso se conoce comoSentence Blímite Disambiguación (SBD) o simplemente romper oraciones.

Las técnicas que usamos para detectar las oraciones en un texto dado, dependen del idioma del texto.

Detección de oraciones usando Java

Podemos detectar las oraciones en el texto dado en Java usando Expresiones Regulares y un conjunto de reglas simples.

Por ejemplo, supongamos que un punto, un signo de interrogación o un signo de exclamación finalizan una oración en el texto dado, luego podemos dividir la oración usando el split() método del Stringclase. Aquí, tenemos que pasar una expresión regular en formato String.

A continuación se muestra el programa que determina las oraciones en un texto dado usando expresiones regulares de Java (split method). Guarde este programa en un archivo con el nombreSentenceDetection_RE.java.

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

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

javac SentenceDetection_RE.java 
java SentenceDetection_RE

Al ejecutarse, el programa anterior crea un documento PDF que muestra el siguiente mensaje.

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

Detección de frases usando OpenNLP

Para detectar sentencias, OpenNLP usa un modelo predefinido, un archivo llamado en-sent.bin. Este modelo predefinido está entrenado para detectar oraciones en un texto sin formato determinado.

los opennlp.tools.sentdetect El paquete contiene las clases y las interfaces que se utilizan para realizar la tarea de detección de frases.

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

  • Carga el en-sent.bin modelo usando el SentenceModel clase

  • Instancia del SentenceDetectorME clase.

  • Detecta las oraciones usando el sentDetect() método de esta clase.

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

Paso 1: carga del modelo

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

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 SentenceModel 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 sentence detector model 
InputStream inputStream = new FileInputStream("C:/OpenNLP_models/ensent.bin"); 
SentenceModel model = new SentenceModel(inputStream);

Paso 2: instanciar la clase SentenceDetectorME

los SentenceDetectorME clase del paquete opennlp.tools.sentdetectcontiene métodos para dividir el texto sin procesar en oraciones. Esta clase usa el modelo de máxima entropía para evaluar los caracteres del final de la oración en una cadena para determinar si significan el final de una oración.

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

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

Paso 3: Detectando la oración

los sentDetect() método del SentenceDetectorMELa clase se usa para detectar las oraciones en el texto sin procesar 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.

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

Example

A continuación se muestra el programa que detecta las oraciones en un texto en bruto determinado. Guarde este programa en un archivo con nombreSentenceDetectionME.java.

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

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

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

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

javac SentenceDetectorME.java 
java SentenceDetectorME

Al ejecutarse, el programa anterior lee la cadena dada y detecta las oraciones en ella y muestra la siguiente salida.

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

Detectando las posiciones de las oraciones

También podemos detectar las posiciones de las oraciones usando el método sentPosDetect () del SentenceDetectorME class.

A continuación se muestran los pasos a seguir para escribir un programa que detecte las posiciones de las oraciones a partir del texto en bruto dado.

Paso 1: carga del modelo

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

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 SentenceModel 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 sentence detector model 
InputStream inputStream = new FileInputStream("C:/OpenNLP_models/en-sent.bin"); 
SentenceModel model = new SentenceModel(inputStream);

Paso 2: instanciar la clase SentenceDetectorME

los SentenceDetectorME clase del paquete opennlp.tools.sentdetectcontiene métodos para dividir el texto sin procesar en oraciones. Esta clase usa el modelo de máxima entropía para evaluar los caracteres del final de la oración en una cadena para determinar si significan el final de una oración.

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

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

Paso 3: Detectando la posición de la oración

los sentPosDetect() método del SentenceDetectorMELa clase se usa para detectar las posiciones de las oraciones 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 como parámetro a este método.

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

Paso 4: imprimir los intervalos de las oraciones

los sentPosDetect() método del SentenceDetectorME clase devuelve una matriz de objetos del tipo Span. La clase llamada Span delopennlp.tools.util paquete se utiliza para almacenar el número entero inicial y final de conjuntos.

Puede almacenar los intervalos devueltos por el sentPosDetect() 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);

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 nombreSentenceDetectionME.java.

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

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

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

javac SentencePosDetection.java 
java SentencePosDetection

Al ejecutarse, el programa anterior lee la cadena dada y detecta las oraciones en ella y muestra la siguiente salida.

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

Oraciones 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 las oraciones y sus intervalos (posiciones) juntos, como se muestra en el siguiente bloque de código.

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

A continuación se muestra el programa para detectar las oraciones del texto en bruto dado y mostrarlas junto con sus posiciones. Guarde este programa en un archivo con nombreSentencesAndPosDetection.java.

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

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

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

javac SentencesAndPosDetection.java 
java SentencesAndPosDetection

Al ejecutarse, el programa anterior lee la cadena dada y detecta las oraciones junto con sus posiciones y muestra la siguiente salida.

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

Detección de probabilidad de oraciones

los getSentenceProbabilities() método del SentenceDetectorME La clase devuelve las probabilidades asociadas con las llamadas más recientes al método sentDetect ().

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

A continuación se muestra el programa para imprimir las probabilidades asociadas con las llamadas al método sentDetect (). Guarde este programa en un archivo con el nombreSentenceDetectionMEProbs.java.

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

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

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

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

javac SentenceDetectionMEProbs.java 
java SentenceDetectionMEProbs

Al ejecutarse, el programa anterior lee la cadena dada, detecta las oraciones y las imprime. Además, también devuelve las probabilidades asociadas con las llamadas más recientes al método sentDetect (), como se muestra a continuación.

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

El proceso de dividir la oración dada en partes más pequeñas (fichas) se conoce como tokenization. En general, el texto sin formato proporcionado se tokeniza en función de un conjunto de delimitadores (principalmente espacios en blanco).

La tokenización se utiliza en tareas como revisión ortográfica, procesamiento de búsquedas, identificación de partes del discurso, detección de oraciones, clasificación de documentos, etc.

Tokenización usando OpenNLP

los opennlp.tools.tokenize El paquete contiene las clases y las interfaces que se utilizan para realizar la tokenización.

Para tokenizar las oraciones dadas en fragmentos más simples, la biblioteca OpenNLP proporciona tres clases diferentes:

  • SimpleTokenizer - Esta clase tokeniza el texto sin procesar dado usando clases de caracteres.

  • WhitespaceTokenizer - Esta clase usa espacios en blanco para tokenizar el texto dado.

  • TokenizerME- Esta clase convierte texto sin formato en tokens separados. Utiliza la máxima entropía para tomar sus decisiones.

SimpleTokenizer

Para tokenizar una oración usando el SimpleTokenizer clase, necesitas -

  • Crea un objeto de la clase respectiva.

  • Tokeniza la oración usando el tokenize() método.

  • Imprime las fichas.

A continuación se muestran los pasos a seguir para escribir un programa que tokenice el texto sin formato dado.

Step 1 - Instanciar la clase respectiva

En ambas clases, no hay constructores disponibles para instanciarlos. Por lo tanto, necesitamos crear objetos de estas clases usando la variable estáticaINSTANCE.

SimpleTokenizer tokenizer = SimpleTokenizer.INSTANCE;

Step 2 - Tokenizar las oraciones

Ambas clases contienen un método llamado tokenize(). Este método acepta un texto sin formato en formato String. Al invocar, tokeniza la cadena dada y devuelve una matriz de cadenas (tokens).

Tokeniza la oración usando el tokenizer() método como se muestra a continuación.

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

Step 3 - Imprime las fichas

Después de tokenizar la oración, puede imprimir los tokens usando for loop, Como se muestra abajo.

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

Example

A continuación se muestra el programa que tokeniza la oración dada usando la clase SimpleTokenizer. Guarde este programa en un archivo con el nombreSimpleTokenizerExample.java.

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

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

javac SimpleTokenizerExample.java 
java SimpleTokenizerExample

Al ejecutarse, el programa anterior lee la cadena dada (texto sin formato), la tokeniza y muestra la siguiente salida:

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

WhitespaceTokenizer

Para tokenizar una oración usando el WhitespaceTokenizer clase, necesitas -

  • Crea un objeto de la clase respectiva.

  • Tokeniza la oración usando el tokenize() método.

  • Imprime las fichas.

A continuación se muestran los pasos a seguir para escribir un programa que tokenice el texto sin formato dado.

Step 1 - Instanciar la clase respectiva

En ambas clases, no hay constructores disponibles para instanciarlos. Por lo tanto, necesitamos crear objetos de estas clases usando la variable estáticaINSTANCE.

WhitespaceTokenizer tokenizer = WhitespaceTokenizer.INSTANCE;

Step 2 - Tokenizar las oraciones

Ambas clases contienen un método llamado tokenize(). Este método acepta un texto sin formato en formato String. Al invocar, tokeniza la cadena dada y devuelve una matriz de cadenas (tokens).

Tokeniza la oración usando el tokenizer() método como se muestra a continuación.

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

Step 3 - Imprime las fichas

Después de tokenizar la oración, puede imprimir los tokens usando for loop, Como se muestra abajo.

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

Example

A continuación se muestra el programa que tokeniza la oración dada usando el WhitespaceTokenizerclase. Guarde este programa en un archivo con el nombreWhitespaceTokenizerExample.java.

import opennlp.tools.tokenize.WhitespaceTokenizer;  

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

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

javac WhitespaceTokenizerExample.java 
java WhitespaceTokenizerExample

Al ejecutarse, el programa anterior lee la cadena dada (texto sin formato), la tokeniza y muestra la siguiente salida.

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

Clase TokenizerME

OpenNLP también usa un modelo predefinido, un archivo llamado de-token.bin, para tokenizar las oraciones. Está entrenado para convertir las oraciones en un texto sin formato determinado.

los TokenizerME clase de la opennlp.tools.tokenizerEl paquete se usa para cargar este modelo y tokenizar el texto sin procesar dado usando la biblioteca OpenNLP. Para hacerlo, necesita:

  • Carga el en-token.bin modelo usando el TokenizerModel clase.

  • Instancia del TokenizerME clase.

  • Tokenize las oraciones usando el tokenize() método de esta clase.

A continuación se muestran los pasos a seguir para escribir un programa que tokenice las oraciones del texto en bruto dado utilizando TokenizerME clase.

Step 1 - Cargando el modelo

El modelo de tokenización está representado por la clase denominada TokenizerModel, que pertenece al paquete opennlp.tools.tokenize.

Para cargar un modelo de tokenizador:

  • 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 TokenizerModel 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 Tokenizer model 
InputStream inputStream = new FileInputStream("C:/OpenNLP_models/en-token.bin"); 
TokenizerModel tokenModel = new TokenizerModel(inputStream);

Step 2 - Creación de instancias de la clase TokenizerME

los TokenizerME clase del paquete opennlp.tools.tokenizecontiene métodos para cortar el texto sin procesar en partes más pequeñas (tokens). Utiliza la máxima entropía para tomar sus decisiones.

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

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

Step 3 - Tokenizando la sentencia

los tokenize() método del TokenizerMELa clase se usa para tokenizar el texto sin procesar que se le pasa. Este método acepta una variable de cadena como parámetro y devuelve una matriz de cadenas (tokens).

Invoque este método pasando el formato String de la oración a este método, de la siguiente manera.

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

Example

A continuación se muestra el programa que tokeniza el texto sin formato dado. Guarde este programa en un archivo con el nombreTokenizerMEExample.java.

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

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

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

javac TokenizerMEExample.java 
java TokenizerMEExample

Al ejecutarse, el programa anterior lee la cadena dada y detecta las oraciones en ella y muestra la siguiente salida:

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

Recuperando las posiciones de los tokens

También podemos conseguir las posiciones o spans de los tokens usando el tokenizePos()método. Este es el método de la interfaz Tokenizer del paquete.opennlp.tools.tokenize. Dado que las (tres) clases de Tokenizer implementan esta interfaz, puede encontrar este método en todas ellas.

Este método acepta la oración o el texto sin formato en forma de cadena y devuelve una matriz de objetos del tipo Span.

Puede obtener las posiciones de los tokens usando el tokenizePos() método, como sigue -

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

Imprimir las posiciones (tramos)

La clase nombrada Span del opennlp.tools.util paquete se utiliza para almacenar el número entero inicial y final de conjuntos.

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

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

Imprimir fichas y sus posiciones juntas

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

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

Example(SimpleTokenizer)

A continuación se muestra el programa que recupera los tramos de token del texto sin formato utilizando el SimpleTokenizerclase. También imprime las fichas junto con sus posiciones. Guarde este programa en un archivo con nombreSimpleTokenizerSpans.java.

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

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

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

javac SimpleTokenizerSpans.java 
java SimpleTokenizerSpans

Al ejecutarse, el programa anterior lee la cadena dada (texto sin formato), la tokeniza y muestra la siguiente salida:

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

Example (WhitespaceTokenizer)

A continuación se muestra el programa que recupera los tramos de token del texto sin formato utilizando el WhitespaceTokenizerclase. También imprime las fichas junto con sus posiciones. Guarde este programa en un archivo con el nombreWhitespaceTokenizerSpans.java.

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

Compile y ejecute el archivo java guardado desde el símbolo del sistema usando los siguientes comandos

javac WhitespaceTokenizerSpans.java 
java WhitespaceTokenizerSpans

Al ejecutarse, el programa anterior lee la cadena dada (texto sin formato), la tokeniza y muestra la siguiente salida.

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

Example (TokenizerME)

A continuación se muestra el programa que recupera los tramos de token del texto sin formato utilizando el TokenizerMEclase. También imprime las fichas junto con sus posiciones. Guarde este programa en un archivo con el nombreTokenizerMESpans.java.

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

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

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

javac TokenizerMESpans.java 
java TokenizerMESpans

Al ejecutarse, el programa anterior lee la cadena dada (texto sin formato), la tokeniza y muestra la siguiente salida:

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

Probabilidad de Tokenizer

El método getTokenProbabilities () de la clase TokenizerME se utiliza para obtener las probabilidades asociadas con las llamadas más recientes al método tokenizePos ().

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

A continuación se muestra el programa para imprimir las probabilidades asociadas con las llamadas al método tokenizePos (). 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 asociadas con las llamadas más recientes al método tokenizerPos ().

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

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 determinado.

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 un 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 llamada 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 ella 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 en bruto 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 ella 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

Con OpenNLP, también puede detectar las partes del habla de una oración determinada e imprimirlas. En lugar del nombre completo de las partes del discurso, OpenNLP usa formas cortas de cada parte del discurso. La siguiente tabla indica las distintas partes de los discursos detectados por OpenNLP y sus significados.

Partes de la oración Significado de las partes del discurso
NN Sustantivo, singular o masa
DT Determinante
VB Verbo, forma base
VBD Verbo, pasado
VBZ Verbo, presente en tercera persona del singular
EN Preposición o conjunción subordinante
NNP Nombre propio, singular
A a
JJ Adjetivo

Etiquetar las partes del habla

Para etiquetar las partes del discurso de una oración, OpenNLP usa un modelo, un archivo llamado en-posmaxent.bin. Este es un modelo predefinido que está entrenado para etiquetar las partes del discurso del texto sin formato dado.

los POSTaggerME clase de la opennlp.tools.postagEl paquete se utiliza para cargar este modelo y etiquetar las partes gramaticales del texto sin formato dado mediante la biblioteca OpenNLP. Para hacerlo, necesita:

  • Carga el en-pos-maxent.bin modelo usando el POSModel clase.

  • Instancia del POSTaggerME clase.

  • Tokeniza la oración.

  • Genere las etiquetas usando tag() método.

  • Imprima los tokens y etiquetas usando POSSample clase.

Los siguientes son los pasos que se deben seguir para escribir un programa que etiquete las partes del discurso en el texto sin procesar dado usando POSTaggerME clase.

Paso 1: carga el modelo

El modelo de etiquetado POS está representado por la clase denominada POSModel, que pertenece al paquete opennlp.tools.postag.

Para cargar un modelo de tokenizador:

  • 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 POSModel 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 Parts of speech-maxent model 
InputStream inputStream = new FileInputStream("C:/OpenNLP_models/en-pos-maxent.bin"); 
POSModel model = new POSModel(inputStream);

Paso 2: instanciar la clase POSTaggerME

los POSTaggerME clase del paquete opennlp.tools.postagse utiliza para predecir las partes gramaticales de un texto sin formato dado. Utiliza la máxima entropía para tomar sus decisiones.

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

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

Paso 3: Tokenizar la oración

los tokenize() método del whitespaceTokenizerLa clase se usa para tokenizar el texto sin procesar que se le pasa. Este método acepta una variable de cadena como parámetro y devuelve una matriz de cadenas (tokens).

Instancia del whitespaceTokenizer class e invocar este método pasando el formato String de la oración a este método.

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

Paso 4: generar las etiquetas

los tag() método del whitespaceTokenizerclass asigna etiquetas POS a la oración de tokens. Este método acepta una matriz de tokens (String) como parámetro y devuelve una etiqueta (matriz).

Invocar el tag() método pasándole los tokens generados en el paso anterior.

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

Paso 5: imprimir los tokens y las etiquetas

los POSSampleclass representa la oración con etiqueta POS. Para instanciar esta clase, necesitaríamos una matriz de tokens (del texto) y una matriz de etiquetas.

los toString()El método de esta clase devuelve la oración etiquetada. Cree una instancia de esta clase pasando el token y las matrices de etiquetas creadas en los pasos anteriores e invoque sutoString() método, como se muestra en el siguiente bloque de código.

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

Example

A continuación se muestra el programa que etiqueta las partes del discurso en un texto en bruto determinado. Guarde este programa en un archivo con el nombrePosTaggerExample.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 Tutorialspoint"; 
       
      //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()); 
   
   } 
}

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

javac PosTaggerExample.java 
java PosTaggerExample

Al ejecutarse, el programa anterior lee el texto dado y detecta las partes del habla de estas oraciones y las muestra, como se muestra a continuación.

Hi_NNP welcome_JJ to_TO Tutorialspoint_VB

Rendimiento del etiquetador POS

A continuación se muestra el programa que etiqueta las partes del discurso de un texto en bruto determinado. También monitorea el desempeño y muestra el desempeño del etiquetador. Guarde este programa en un archivo con el nombrePosTagger_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 Tutorialspoint"; 
      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();      
   } 
}

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

javac PosTaggerExample.java 
java PosTaggerExample

Al ejecutarse, el programa anterior lee el texto dado y etiqueta las partes del discurso de estas oraciones y las muestra. Además, también supervisa el rendimiento del etiquetador POS y lo muestra.

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

Probabilidad de etiquetado POS

los probs() método del POSTaggerME class se usa para encontrar las probabilidades de cada etiqueta de la oración etiquetada recientemente.

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

A continuación se muestra el programa que muestra las probabilidades de cada etiqueta de la última oración etiquetada. Guarde este programa en un archivo con el nombrePosTaggerProbs.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 Tutorialspoint"; 
      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]); 
   } 
}

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 el texto en bruto dado, etiqueta las partes del habla de cada token que contiene y las muestra. Además, también muestra las probabilidades para cada parte del discurso en la oración dada, como se muestra a continuación.

Hi_NNP welcome_JJ to_TO Tutorialspoint_VB    
0.6416834779738033 
0.42983612874819177 
0.8584513635863117 
0.4394784478206072

Usando la API de OpenNLP, puede analizar las oraciones dadas. En este capítulo, discutiremos cómo analizar texto sin formato usando la API de OpenNLP.

Análisis de texto sin formato mediante la biblioteca OpenNLP

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

los Parser clase de la opennlp.tools.Parser paquete se utiliza para contener los componentes de análisis y el ParserTool clase de la opennlp.tools.cmdline.parser El paquete se utiliza para analizar el contenido.

A continuación se muestran los pasos que se deben seguir para escribir un programa que analiza el texto en bruto dado utilizando el ParserTool clase.

Paso 1: carga del modelo

El modelo para analizar el texto está representado por la clase denominada ParserModel, que pertenece al paquete opennlp.tools.parser.

Para cargar un modelo de tokenizador:

  • 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 ParserModel 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 parser model 
InputStream inputStream = new FileInputStream(".../en-parserchunking.bin"); 
ParserModel model = new ParserModel(inputStream);

Paso 2: crear un objeto de la clase Analizador

los Parser clase del paquete opennlp.tools.parserrepresenta una estructura de datos para contener componentes de análisis. Puedes crear un objeto de esta clase usando el staticcreate() método del ParserFactory clase.

Invocar el create() método del ParserFactory pasando el objeto modelo creado en el paso anterior, como se muestra a continuación:

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

Paso 3: analizar la oración

los parseLine() método del ParserToolLa clase se utiliza para analizar el texto sin formato en OpenNLP. Este método acepta:

  • una variable de cadena que representa el texto que se va a analizar.

  • un objeto analizador.

  • un número entero que representa el número de análisis que se van a realizar.

Invoque este método pasando a la oración los siguientes parámetros: el objeto de análisis creado en los pasos anteriores y un número entero que representa el número requerido de análisis que se van a realizar.

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

Example

A continuación se muestra el programa que analiza el texto sin formato dado. Guarde este programa en un archivo con el nombreParserExample.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 = "Tutorialspoint is the largest tutorial library.";
      Parse topParses[] = ParserTool.parseLine(sentence, parser, 1); 
    
      for (Parse p : topParses) 
         p.show();          
   } 
}

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

javac ParserExample.java 
java ParserExample

Al ejecutarse, el programa anterior lee el texto sin formato dado, lo analiza y muestra la siguiente salida:

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

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

OpenNLP proporciona una interfaz de línea de comandos (CLI) para realizar diferentes operaciones a través de la línea de comandos. En este capítulo, tomaremos algunos ejemplos para mostrar cómo podemos usar la interfaz de línea de comandos de OpenNLP.

Tokenización

input.txt

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

Sintaxis

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

mando

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

salida

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 Tutorialspoint . We provide free tutorials on various technologies

Detección de frases

input.txt

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

Sintaxis

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

mando

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

Salida

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 Tutorialspoint. 
We provide free tutorials on various technologies

Reconocimiento de entidad nombrada

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 Tutorialspoint

Sintaxis

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

Mando

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

Salida

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 Tutorialspoint  
Average: 55.6 sent/s 
Total: 1 sent 
Runtime: 0.018s

Partes del etiquetado del habla

Input.txt

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

Sintaxis

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

Mando

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

Salida

Loading POS Tagger model ... done (1.315s) 
Hi._NNP How_WRB are_VBP you?_JJ Welcome_NNP to_TO Tutorialspoint._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