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