OpenNLP - Guia Rápido

PNL é um conjunto de ferramentas usado para obter informações significativas e úteis de fontes de linguagem natural, como páginas da web e documentos de texto.

O que é Open NLP?

Apache OpenNLPé uma biblioteca Java de código aberto usada para processar texto em linguagem natural. Você pode construir um serviço de processamento de texto eficiente usando esta biblioteca.

O OpenNLP fornece serviços como tokenização, segmentação de frase, marcação de parte da fala, extração de entidade nomeada, chunking, análise e resolução de co-referência, etc.

Recursos do OpenNLP

A seguir estão os recursos notáveis ​​do OpenNLP -

  • Named Entity Recognition (NER) - Open NLP suporta NER, usando o qual você pode extrair nomes de locais, pessoas e coisas, mesmo durante o processamento de consultas.

  • Summarize - Usando o summarize recurso, você pode resumir Parágrafos, artigos, documentos ou sua coleção em PNL.

  • Searching - No OpenNLP, uma determinada string de pesquisa ou seus sinônimos podem ser identificados em um determinado texto, mesmo que a palavra dada seja alterada ou incorreta.

  • Tagging (POS) - A marcação em PNL é usada para dividir o texto em vários elementos gramaticais para análise posterior.

  • Translation - Na PNL, a tradução ajuda a traduzir um idioma para outro.

  • Information grouping - Esta opção em PNL agrupa as informações textuais no conteúdo do documento, assim como partes do discurso.

  • Natural Language Generation - É usado para gerar informações a partir de um banco de dados e automatizar os relatórios de informações como análises meteorológicas ou relatórios médicos.

  • Feedback Analysis - Como o nome indica, vários tipos de feedbacks de pessoas são coletados, em relação aos produtos, pela PNL para analisar se o produto é bem-sucedido em conquistar seus corações.

  • Speech recognition - Embora seja difícil analisar a fala humana, a PNL possui alguns recursos internos para esse requisito.

API Open NLP

A biblioteca Apache OpenNLP fornece classes e interfaces para realizar várias tarefas de processamento de linguagem natural, como detecção de sentenças, tokenização, localização de um nome, marcação de classes gramaticais, fragmentação de sentenças, análise, resolução de co-referência e categorização de documentos.

Além dessas tarefas, também podemos treinar e avaliar nossos próprios modelos para qualquer uma dessas tarefas.

OpenNLP CLI

Além da biblioteca, o OpenNLP também oferece uma Command Line Interface (CLI), onde podemos treinar e avaliar modelos. Discutiremos esse tópico em detalhes no último capítulo deste tutorial.

Modelos de PNL abertos

Para realizar várias tarefas de PNL, o OpenNLP fornece um conjunto de modelos predefinidos. Este conjunto inclui modelos para diferentes idiomas.

Baixando os modelos

Você pode seguir as etapas abaixo para baixar os modelos predefinidos fornecidos pelo OpenNLP.

Step 1 - Abra a página de índice dos modelos OpenNLP clicando no seguinte link - http://opennlp.sourceforge.net/models-1.5/.

Step 2- Ao visitar o link fornecido, você verá uma lista de componentes em vários idiomas e os links para baixá-los. Aqui, você pode obter a lista de todos os modelos predefinidos fornecidos pelo OpenNLP.

Baixe todos esses modelos para a pasta C:/OpenNLP_models/>, clicando em seus respectivos links. Todos esses modelos dependem do idioma e, ao usá-los, você deve certificar-se de que o idioma do modelo corresponda ao idioma do texto de entrada.

História do OpenNLP

  • Em 2010, o OpenNLP entrou na incubação Apache.

  • Em 2011, o Apache OpenNLP 1.5.2 Incubating foi lançado e, no mesmo ano, graduou-se como um projeto Apache de nível superior.

  • Em 2015, o OpenNLP foi lançado 1.6.0.

Neste capítulo, discutiremos como você pode configurar o ambiente OpenNLP em seu sistema. Vamos começar com o processo de instalação.

Instalando OpenNLP

A seguir estão as etapas para baixar Apache OpenNLP library em seu sistema.

Step 1 - Abra a página inicial de Apache OpenNLP clicando no seguinte link - https://opennlp.apache.org/.

Step 2 - Agora, clique no Downloadsligação. Ao clicar, você será direcionado a uma página onde poderá encontrar vários mirrors que o redirecionarão para o diretório de distribuição do Apache Software Foundation.

Step 3- Nesta página você pode encontrar links para baixar várias distribuições do Apache. Navegue por eles e encontre a distribuição OpenNLP e clique nela.

Step 4 - Ao clicar, você será redirecionado para o diretório onde poderá ver o índice da distribuição OpenNLP, conforme mostrado abaixo.

Clique na versão mais recente das distribuições disponíveis.

Step 5- Cada distribuição fornece arquivos fonte e binários da biblioteca OpenNLP em vários formatos. Baixe os arquivos de origem e binários,apache-opennlp-1.6.0-bin.zip e apache-opennlp1.6.0-src.zip (para Windows).

Configurando o Classpath

Depois de baixar a biblioteca OpenNLP, você precisa definir seu caminho para o bindiretório. Suponha que você tenha baixado a biblioteca OpenNLP para a unidade E do seu sistema.

Agora, siga as etapas fornecidas abaixo -

Step 1 - Clique com o botão direito em 'Meu Computador' e selecione 'Propriedades'.

Step 2 - Clique no botão 'Variáveis ​​de ambiente' na guia 'Avançado'.

Step 3 - Selecione o path variável e clique no Edit botão, como mostrado na imagem a seguir.

Step 4 - Na janela Editar Variável de Ambiente, clique no botão New botão e adicione o caminho para o diretório OpenNLP E:\apache-opennlp-1.6.0\bin e clique no OK botão, como mostrado na imagem a seguir.

Instalação Eclipse

Você pode definir o ambiente Eclipse para a biblioteca OpenNLP, definindo o Build path para os arquivos JAR ou usando pom.xml.

Definindo o caminho de construção para os arquivos JAR

Siga as etapas abaixo para instalar o OpenNLP no Eclipse -

Step 1 - Certifique-se de ter o ambiente Eclipse instalado em seu sistema.

Step 2- Abra o Eclipse. Clique em Arquivo → Novo → Abrir um novo projeto, conforme mostrado abaixo.

Step 3 - Você vai conseguir o New ProjectMago. Neste assistente, selecione o projeto Java e continue clicando noNext botão.

Step 4 - Em seguida, você obterá o New Java Project wizard. Aqui, você precisa criar um novo projeto e clicar no botãoNext botão, como mostrado abaixo.

Step 5 - Depois de criar um novo projeto, clique com o botão direito sobre ele, selecione Build Path e clique Configure Build Path.

Step 6 - Em seguida, você obterá o Java Build PathMago. Aqui, clique noAdd External JARs botão, como mostrado abaixo.

Step 7 - Selecione os arquivos jar opennlp-tools-1.6.0.jar e opennlp-uima-1.6.0.jar localizado no lib pasta de apache-opennlp-1.6.0 folder.

Ao clicar no Open botão na tela acima, os arquivos selecionados serão adicionados à sua biblioteca.

Ao clicar OK, você adicionará com êxito os arquivos JAR necessários ao projeto atual e poderá verificar essas bibliotecas adicionadas expandindo as Bibliotecas Referidas, conforme mostrado abaixo.

Usando pom.xml

Converta o projeto em um projeto Maven e adicione o seguinte código ao seu 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>

Neste capítulo, discutiremos sobre as classes e métodos que usaremos nos capítulos subsequentes deste tutorial.

Detecção de frases

Classe SentençaModel

Esta classe representa o modelo predefinido que é usado para detectar as sentenças em um determinado texto bruto. Esta classe pertence ao pacoteopennlp.tools.sentdetect.

O construtor desta classe aceita um InputStream objeto do arquivo de modelo do detector de frases (en-sent.bin).

Classe SentençaDetectorME

Esta classe pertence ao pacote opennlp.tools.sentdetecte contém métodos para dividir o texto bruto em frases. Esta classe usa um modelo de entropia máxima para avaliar caracteres de fim de frase em uma string para determinar se eles significam o fim de uma frase.

A seguir estão os métodos importantes desta classe.

S.Não Métodos e Descrição
1

sentDetect()

Este método é usado para detectar as sentenças no texto bruto transmitido a ele. Ele aceita uma variável String como parâmetro e retorna um array String que contém as sentenças do texto bruto fornecido.

2

sentPosDetect()

Este método é usado para detectar as posições das sentenças no texto fornecido. Este método aceita uma variável string, que representa a frase e retorna uma matriz de objetos do tipoSpan.

A classe chamada Span do opennlp.tools.util pacote é usado para armazenar o inteiro inicial e final dos conjuntos.

3

getSentenceProbabilities()

Este método retorna as probabilidades associadas às chamadas mais recentes para sentDetect() método.

Tokenização

Classe TokenizerModel

Esta classe representa o modelo predefinido que é usado para tokenizar a frase dada. Esta classe pertence ao pacoteopennlp.tools.tokenizer.

O construtor desta classe aceita um InputStream objeto do arquivo de modelo do tokenizer (entoken.bin).

Aulas

Para realizar a tokenização, a biblioteca OpenNLP fornece três classes principais. Todas as três classes implementam a interface chamadaTokenizer.

S.Não Classes e Descrição
1

SimpleTokenizer

Esta classe simboliza o texto bruto fornecido usando classes de caracteres.

2

WhitespaceTokenizer

Esta classe usa espaços em branco para tokenizar o texto fornecido.

3

TokenizerME

Esta classe converte texto bruto em tokens separados. Ele usa Entropia Máxima para tomar suas decisões.

Essas classes contêm os seguintes métodos.

S.Não Métodos e Descrição
1

tokenize()

Este método é usado para tokenizar o texto bruto. Este método aceita uma variável String como parâmetro e retorna uma matriz de Strings (tokens).

2

sentPosDetect()

Este método é usado para obter as posições ou extensões dos tokens. Ele aceita a frase (ou) texto bruto na forma de string e retorna uma matriz de objetos do tipoSpan.

Além dos dois métodos acima, o TokenizerME classe tem o getTokenProbabilities() método.

S.Não Métodos e Descrição
1

getTokenProbabilities()

Este método é usado para obter as probabilidades associadas às chamadas mais recentes para o tokenizePos() método.

NameEntityRecognition

Classe TokenNameFinderModel

Esta classe representa o modelo predefinido que é usado para encontrar as entidades nomeadas na frase dada. Esta classe pertence ao pacoteopennlp.tools.namefind.

O construtor desta classe aceita um InputStream objeto do arquivo de modelo do localizador de nomes (enner-person.bin).

Classe NameFinderME

A classe pertence ao pacote opennlp.tools.namefinde contém métodos para realizar as tarefas NER. Esta classe usa um modelo de entropia máxima para encontrar as entidades nomeadas no texto bruto fornecido.

S.Não Métodos e Descrição
1

find()

Este método é usado para detectar os nomes no texto bruto. Ele aceita uma variável String que representa o texto bruto como um parâmetro e retorna um array de objetos do tipo Span.

2

probs()

Este método é usado para obter as probabilidades da última sequência decodificada.

Encontrando as partes do discurso

Classe POSModel

Esta classe representa o modelo predefinido que é usado para marcar as classes gramaticais de uma determinada frase. Esta classe pertence ao pacoteopennlp.tools.postag.

O construtor desta classe aceita um InputStream objeto do arquivo de modelo pos-tagger (enpos-maxent.bin).

Classe POSTaggerME

Esta classe pertence ao pacote opennlp.tools.postage é usado para prever as classes gramaticais de um determinado texto bruto. Ele usa Entropia Máxima para tomar suas decisões.

S.Não Métodos e Descrição
1

tag()

Este método é usado para atribuir a frase de marcas de tokens POS. Este método aceita um array de tokens (String) como parâmetro e retorna uma tag (array).

2

getSentenceProbabilities()

Este método é usado para obter as probabilidades de cada tag da frase recentemente marcada.

Analisando a frase

Classe ParserModel

Esta classe representa o modelo predefinido que é usado para analisar a frase dada. Esta classe pertence ao pacoteopennlp.tools.parser.

O construtor desta classe aceita um InputStream objeto do arquivo de modelo do analisador (en-parserchunking.bin).

Classe Parser Factory

Esta classe pertence ao pacote opennlp.tools.parser e é usado para criar analisadores.

S.Não Métodos e Descrição
1

create()

Este é um método estático e é usado para criar um objeto analisador. Este método aceita o objeto Filestream do arquivo de modelo do analisador.

Classe ParserTool

Esta classe pertence ao opennlp.tools.cmdline.parser pacote e, é usado para analisar o conteúdo.

S.Não Métodos e Descrição
1

parseLine()

Este método do ParserToolclasse é usada para analisar o texto bruto no OpenNLP. Este método aceita -

  • Uma variável String que representa o texto a ser analisado.
  • Um objeto analisador.
  • Um número inteiro que representa o número de análises a serem realizadas.

Chunking

Classe ChunkerModel

Esta classe representa o modelo predefinido que é usado para dividir uma frase em partes menores. Esta classe pertence ao pacoteopennlp.tools.chunker.

O construtor desta classe aceita um InputStream objeto do chunker arquivo de modelo (enchunker.bin).

Classe ChunkerME

Esta classe pertence ao pacote denominado opennlp.tools.chunker e é usado para dividir a frase dada em pedaços menores.

S.Não Métodos e Descrição
1

chunk()

Este método é usado para dividir a frase dada em partes menores. Aceita tokens de uma frase ePartes Of Stags peech como parâmetros.

2

probs()

Este método retorna as probabilidades da última sequência decodificada.

Ao processar uma linguagem natural, decidir o início e o fim das frases é um dos problemas a serem enfrentados. Este processo é conhecido comoSentence Bexterior Disambiguação (SBD) ou simplesmente quebra de frase.

As técnicas que usamos para detectar as sentenças em um determinado texto dependem do idioma do texto.

Detecção de frases usando Java

Podemos detectar as sentenças no texto fornecido em Java usando Expressões regulares e um conjunto de regras simples.

Por exemplo, vamos supor que um ponto final, um ponto de interrogação ou um ponto de exclamação encerre uma frase no texto fornecido, então podemos dividir a frase usando o split() método do Stringclasse. Aqui, temos que passar uma expressão regular no formato String.

A seguir está o programa que determina as sentenças em um determinado texto usando expressões regulares Java (split method). Salve este programa em um arquivo com o nomeSentenceDetection_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 e execute o arquivo java salvo no prompt de comando usando os comandos a seguir.

javac SentenceDetection_RE.java 
java SentenceDetection_RE

Ao ser executado, o programa acima cria um documento PDF exibindo a seguinte mensagem.

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

Detecção de frases usando OpenNLP

Para detectar frases, o OpenNLP usa um modelo predefinido, um arquivo chamado en-sent.bin. Este modelo predefinido é treinado para detectar frases em um determinado texto bruto.

o opennlp.tools.sentdetect pacote contém as classes e interfaces que são usadas para realizar a tarefa de detecção de frases.

Para detectar uma frase usando a biblioteca OpenNLP, você precisa -

  • Carregue o en-sent.bin modelo usando o SentenceModel classe

  • Instancie o SentenceDetectorME classe.

  • Detecte as sentenças usando o sentDetect() método desta classe.

A seguir estão os passos a serem seguidos para escrever um programa que detecta as sentenças de um determinado texto bruto.

Etapa 1: Carregando o modelo

O modelo para detecção de frases é representado pela classe chamada SentenceModel, que pertence ao pacote opennlp.tools.sentdetect.

Para carregar um modelo de detecção de frase -

  • Criar um InputStream objeto do modelo (instancie o FileInputStream e passe o caminho do modelo no formato String para seu construtor).

  • Instancie o SentenceModel classe e passar no InputStream (objeto) do modelo como um parâmetro para seu construtor, conforme mostrado no seguinte bloco de código -

//Loading sentence detector model 
InputStream inputStream = new FileInputStream("C:/OpenNLP_models/ensent.bin"); 
SentenceModel model = new SentenceModel(inputStream);

Etapa 2: instanciando a classe SentençaDetectorME

o SentenceDetectorME classe do pacote opennlp.tools.sentdetectcontém métodos para dividir o texto bruto em frases. Esta classe usa o modelo de Entropia Máxima para avaliar caracteres de fim de frase em uma string para determinar se eles significam o fim de uma frase.

Instancie esta classe e passe o objeto modelo criado na etapa anterior, conforme mostrado abaixo.

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

Etapa 3: Detectando a frase

o sentDetect() método do SentenceDetectorMEclasse é usada para detectar as sentenças no texto bruto passado a ela. Este método aceita uma variável String como parâmetro.

Chame este método passando o formato String da frase para este método.

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

Example

A seguir está o programa que detecta as sentenças em um determinado texto bruto. Salve este programa em um arquivo com o nomeSentenceDetectionME.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 e execute o arquivo Java salvo no prompt de comando usando os seguintes comandos -

javac SentenceDetectorME.java 
java SentenceDetectorME

Ao ser executado, o programa acima lê a String fornecida, detecta as sentenças nela e exibe a seguinte saída.

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

Detectando as posições das sentenças

Também podemos detectar as posições das sentenças usando o método sentPosDetect () do SentenceDetectorME class.

A seguir estão os passos a serem seguidos para escrever um programa que detecta as posições das sentenças de um determinado texto bruto.

Etapa 1: Carregando o modelo

O modelo para detecção de frases é representado pela classe chamada SentenceModel, que pertence ao pacote opennlp.tools.sentdetect.

Para carregar um modelo de detecção de frase -

  • Criar um InputStream objeto do modelo (instancie o FileInputStream e passe o caminho do modelo no formato String para seu construtor).

  • Instancie o SentenceModel classe e passar no InputStream (objeto) do modelo como um parâmetro para seu construtor, conforme mostrado no bloco de código a seguir.

//Loading sentence detector model 
InputStream inputStream = new FileInputStream("C:/OpenNLP_models/en-sent.bin"); 
SentenceModel model = new SentenceModel(inputStream);

Etapa 2: instanciando a classe SentençaDetectorME

o SentenceDetectorME classe do pacote opennlp.tools.sentdetectcontém métodos para dividir o texto bruto em frases. Esta classe usa o modelo de Entropia Máxima para avaliar caracteres de fim de frase em uma string para determinar se eles significam o fim de uma frase.

Instancie essa classe e transmita o objeto modelo criado na etapa anterior.

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

Etapa 3: Detectando a posição da frase

o sentPosDetect() método do SentenceDetectorMEclasse é usada para detectar as posições das sentenças no texto bruto passado a ela. Este método aceita uma variável String como parâmetro.

Invoque este método passando o formato String da frase como um parâmetro para este método.

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

Etapa 4: imprimir as extensões das frases

o sentPosDetect() método do SentenceDetectorME classe retorna uma matriz de objetos do tipo Span. A classe chamada Span of theopennlp.tools.util pacote é usado para armazenar o inteiro inicial e final dos conjuntos.

Você pode armazenar os vãos retornados pelo sentPosDetect() na matriz Span e imprima-os, conforme mostrado no bloco de código a seguir.

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

Example

A seguir está o programa que detecta as sentenças no texto bruto fornecido. Salve este programa em um arquivo com o nomeSentenceDetectionME.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 e execute o arquivo Java salvo no prompt de comando usando os seguintes comandos -

javac SentencePosDetection.java 
java SentencePosDetection

Ao ser executado, o programa acima lê a String fornecida, detecta as sentenças nela e exibe a seguinte saída.

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

Frases juntamente com suas posições

o substring() método da classe String aceita o begin e a end offsetse retorna a respectiva string. Podemos usar esse método para imprimir as frases e seus intervalos (posições) juntos, conforme mostrado no bloco de código a seguir.

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

A seguir está o programa para detectar as frases do texto bruto fornecido e exibi-las junto com suas posições. Salve este programa em um arquivo com o nomeSentencesAndPosDetection.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 e execute o arquivo Java salvo no prompt de comando usando os seguintes comandos -

javac SentencesAndPosDetection.java 
java SentencesAndPosDetection

Ao ser executado, o programa acima lê a String fornecida e detecta as sentenças junto com suas posições e exibe a seguinte saída.

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

Detecção de probabilidade de sentença

o getSentenceProbabilities() método do SentenceDetectorME classe retorna as probabilidades associadas às chamadas mais recentes para o método sentDetect ().

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

A seguir está o programa para imprimir as probabilidades associadas às chamadas para o método sentDetect (). Salve este programa em um arquivo com o nomeSentenceDetectionMEProbs.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 e execute o arquivo Java salvo no prompt de comando usando os seguintes comandos -

javac SentenceDetectionMEProbs.java 
java SentenceDetectionMEProbs

Ao ser executado, o programa acima lê a String fornecida, detecta as sentenças e as imprime. Além disso, ele também retorna as probabilidades associadas às chamadas mais recentes para o método sentDetect (), conforme mostrado abaixo.

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

O processo de cortar a frase dada em partes menores (tokens) é conhecido como tokenization. Em geral, o texto bruto fornecido é marcado com base em um conjunto de delimitadores (principalmente espaços em branco).

A tokenização é usada em tarefas como verificação ortográfica, processamento de pesquisas, identificação de classes gramaticais, detecção de frases, classificação de documentos de documentos, etc.

Tokenização usando OpenNLP

o opennlp.tools.tokenize pacote contém as classes e interfaces que são usadas para realizar a tokenização.

Para tokenizar as frases fornecidas em fragmentos mais simples, a biblioteca OpenNLP oferece três classes diferentes -

  • SimpleTokenizer - Esta classe simboliza o texto bruto fornecido usando classes de caracteres.

  • WhitespaceTokenizer - Esta classe usa espaços em branco para tokenizar o texto fornecido.

  • TokenizerME- Esta classe converte texto bruto em tokens separados. Ele usa Entropia Máxima para tomar suas decisões.

SimpleTokenizer

Para tokenizar uma frase usando o SimpleTokenizer classe, você precisa -

  • Crie um objeto da respectiva classe.

  • Tokenize a frase usando o tokenize() método.

  • Imprima os tokens.

A seguir estão os passos a serem seguidos para escrever um programa que tokenize o texto bruto fornecido.

Step 1 - Instanciando a respectiva classe

Em ambas as classes, não há construtores disponíveis para instanciá-los. Portanto, precisamos criar objetos dessas classes usando a variável estáticaINSTANCE.

SimpleTokenizer tokenizer = SimpleTokenizer.INSTANCE;

Step 2 - Tokenizar as frases

Ambas as classes contêm um método chamado tokenize(). Este método aceita um texto bruto no formato String. Ao invocar, ele simboliza a String fornecida e retorna uma matriz de Strings (tokens).

Tokenize a frase usando o tokenizer() método conforme mostrado abaixo.

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

Step 3 - Imprima os tokens

Depois de tokenizar a frase, você pode imprimir os tokens usando for loop, como mostrado abaixo.

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

Example

A seguir está o programa que simboliza a frase fornecida usando a classe SimpleTokenizer. Salve este programa em um arquivo com o nomeSimpleTokenizerExample.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 e execute o arquivo Java salvo no prompt de comando usando os seguintes comandos -

javac SimpleTokenizerExample.java 
java SimpleTokenizerExample

Ao ser executado, o programa acima lê a string fornecida (texto bruto), transforma-a em token e exibe a seguinte saída -

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

WhitespaceTokenizer

Para tokenizar uma frase usando o WhitespaceTokenizer classe, você precisa -

  • Crie um objeto da respectiva classe.

  • Tokenize a frase usando o tokenize() método.

  • Imprima os tokens.

A seguir estão os passos a serem seguidos para escrever um programa que tokenize o texto bruto fornecido.

Step 1 - Instanciando a respectiva classe

Em ambas as classes, não há construtores disponíveis para instanciá-los. Portanto, precisamos criar objetos dessas classes usando a variável estáticaINSTANCE.

WhitespaceTokenizer tokenizer = WhitespaceTokenizer.INSTANCE;

Step 2 - Tokenizar as frases

Ambas as classes contêm um método chamado tokenize(). Este método aceita um texto bruto no formato String. Ao invocar, ele simboliza a String fornecida e retorna uma matriz de Strings (tokens).

Tokenize a frase usando o tokenizer() método conforme mostrado abaixo.

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

Step 3 - Imprima os tokens

Depois de tokenizar a frase, você pode imprimir os tokens usando for loop, como mostrado abaixo.

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

Example

A seguir está o programa que simboliza a frase dada usando o WhitespaceTokenizerclasse. Salve este programa em um arquivo com o nomeWhitespaceTokenizerExample.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 e execute o arquivo Java salvo no prompt de comando usando os seguintes comandos -

javac WhitespaceTokenizerExample.java 
java WhitespaceTokenizerExample

Ao ser executado, o programa acima lê a String fornecida (texto bruto), transforma-a em token e exibe a seguinte saída.

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

Classe TokenizerME

O OpenNLP também usa um modelo predefinido, um arquivo denominado de-token.bin, para tokenizar as frases. Ele é treinado para tokenizar as sentenças em um determinado texto bruto.

o TokenizerME classe do opennlp.tools.tokenizerpacote é usado para carregar este modelo e tokenizar o texto bruto fornecido usando a biblioteca OpenNLP. Para fazer isso, você precisa -

  • Carregue o en-token.bin modelo usando o TokenizerModel classe.

  • Instancie o TokenizerME classe.

  • Tokenize as frases usando o tokenize() método desta classe.

A seguir estão os passos a serem seguidos para escrever um programa que tokenizar as sentenças do texto bruto fornecido usando o TokenizerME classe.

Step 1 - Carregando o modelo

O modelo de tokenização é representado pela classe chamada TokenizerModel, que pertence ao pacote opennlp.tools.tokenize.

Para carregar um modelo de tokenizer -

  • Criar um InputStream objeto do modelo (instancie o FileInputStream e passe o caminho do modelo no formato String para seu construtor).

  • Instancie o TokenizerModel classe e passar no InputStream (objeto) do modelo como um parâmetro para seu construtor, conforme mostrado no bloco de código a seguir.

//Loading the Tokenizer model 
InputStream inputStream = new FileInputStream("C:/OpenNLP_models/en-token.bin"); 
TokenizerModel tokenModel = new TokenizerModel(inputStream);

Step 2 - Instanciando a classe TokenizerME

o TokenizerME classe do pacote opennlp.tools.tokenizecontém métodos para dividir o texto bruto em partes menores (tokens). Ele usa Entropia Máxima para tomar suas decisões.

Instancie essa classe e passe o objeto modelo criado na etapa anterior, conforme mostrado abaixo.

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

Step 3 - Tokenização da frase

o tokenize() método do TokenizerMEclasse é usada para tokenizar o texto bruto passado a ela. Este método aceita uma variável String como parâmetro e retorna uma matriz de Strings (tokens).

Chame este método passando o formato String da frase para este método, como segue.

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

Example

A seguir está o programa que simboliza o texto bruto fornecido. Salve este programa em um arquivo com o nomeTokenizerMEExample.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 e execute o arquivo Java salvo no prompt de comando usando os seguintes comandos -

javac TokenizerMEExample.java 
java TokenizerMEExample

Ao ser executado, o programa acima lê a string fornecida e detecta as sentenças nela e exibe a seguinte saída -

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

Recuperando as posições dos tokens

Também podemos obter as posições ou spans dos tokens usando o tokenizePos()método. Este é o método da interface Tokenizer do pacoteopennlp.tools.tokenize. Uma vez que todas as (três) classes de Tokenizer implementam essa interface, você pode encontrar esse método em todas elas.

Este método aceita a frase ou texto bruto na forma de uma string e retorna uma matriz de objetos do tipo Span.

Você pode obter as posições dos tokens usando o tokenizePos() método, como segue -

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

Imprimindo as posições (spans)

A classe chamada Span do opennlp.tools.util pacote é usado para armazenar o inteiro inicial e final dos conjuntos.

Você pode armazenar os vãos retornados pelo tokenizePos() na matriz Span e imprima-os, conforme mostrado no bloco de código a seguir.

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

Imprimir tokens e suas posições juntos

o substring() método da classe String aceita o begin e a enddesloca e retorna a respectiva string. Podemos usar esse método para imprimir os tokens e seus intervalos (posições) juntos, conforme mostrado no bloco de código a seguir.

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

Example(SimpleTokenizer)

A seguir está o programa que recupera as extensões de token do texto bruto usando o SimpleTokenizerclasse. Ele também imprime os tokens junto com suas posições. Salve este programa em um arquivo com o nomeSimpleTokenizerSpans.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 e execute o arquivo Java salvo no prompt de comando usando os seguintes comandos -

javac SimpleTokenizerSpans.java 
java SimpleTokenizerSpans

Ao ser executado, o programa acima lê a string fornecida (texto bruto), transforma-a em token e exibe a seguinte saída -

[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 seguir está o programa que recupera as extensões de token do texto bruto usando o WhitespaceTokenizerclasse. Ele também imprime os tokens junto com suas posições. Salve este programa em um arquivo com o nomeWhitespaceTokenizerSpans.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 e execute o arquivo java salvo a partir do prompt de comando usando os seguintes comandos

javac WhitespaceTokenizerSpans.java 
java WhitespaceTokenizerSpans

Ao ser executado, o programa acima lê a String fornecida (texto bruto), transforma-a em token e exibe a seguinte saída.

[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 seguir está o programa que recupera as extensões de token do texto bruto usando o TokenizerMEclasse. Ele também imprime os tokens junto com suas posições. Salve este programa em um arquivo com o nomeTokenizerMESpans.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 e execute o arquivo Java salvo no prompt de comando usando os seguintes comandos -

javac TokenizerMESpans.java 
java TokenizerMESpans

Ao ser executado, o programa acima lê a string fornecida (texto bruto), transforma-a em token e exibe a seguinte saída -

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

Probabilidade de Tokenizer

O método getTokenProbabilities () da classe TokenizerME é usado para obter as probabilidades associadas às chamadas mais recentes para o método tokenizePos ().

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

A seguir está o programa para imprimir as probabilidades associadas às chamadas para o método tokenizePos (). Salve este programa em um arquivo com o nomeTokenizerMEProbs.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 e execute o arquivo Java salvo no prompt de comando usando os seguintes comandos -

javac TokenizerMEProbs.java 
java TokenizerMEProbs

Ao ser executado, o programa acima lê a String fornecida, transforma as frases em token e as imprime. Além disso, ele também retorna as probabilidades associadas às chamadas mais recentes para o 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

O processo de localização de nomes, pessoas, lugares e outras entidades a partir de um determinado texto é conhecido como Named Entity Recognição (NER). Neste capítulo, discutiremos como realizar NER por meio do programa Java usando a biblioteca OpenNLP.

Reconhecimento de entidade nomeada usando PNL aberta

Para realizar várias tarefas NER, o OpenNLP usa diferentes modelos predefinidos, a saber, en-nerdate.bn, en-ner-location.bin, en-ner-organization.bin, en-ner-person.bin e en-ner-time. bin. Todos esses arquivos são modelos predefinidos que são treinados para detectar as respectivas entidades em um determinado texto bruto.

o opennlp.tools.namefindpacote contém as classes e interfaces que são usadas para executar a tarefa NER. Para executar a tarefa NER usando a biblioteca OpenNLP, você precisa -

  • Carregue o respectivo modelo usando o TokenNameFinderModel classe.

  • Instancie o NameFinder classe.

  • Encontre os nomes e imprima-os.

A seguir estão os passos a serem seguidos para escrever um programa que detecta as entidades de nome de um determinado texto bruto.

Etapa 1: Carregando o modelo

O modelo para detecção de frases é representado pela classe chamada TokenNameFinderModel, que pertence ao pacote opennlp.tools.namefind.

Para carregar um modelo NER -

  • Criar um InputStream objeto do modelo (instancie o FileInputStream e passe o caminho do modelo NER apropriado no formato String para seu construtor).

  • Instancie o TokenNameFinderModel classe e passar no InputStream (objeto) do modelo como um parâmetro para seu construtor, conforme mostrado no bloco de código a seguir.

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

Etapa 2: instanciando a classe NameFinderME

o NameFinderME classe do pacote opennlp.tools.namefindcontém métodos para executar as tarefas NER. Esta classe usa o modelo de Entropia Máxima para encontrar as entidades nomeadas no texto bruto fornecido.

Instancie esta classe e passe o objeto modelo criado na etapa anterior, conforme mostrado abaixo -

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

Etapa 3: Encontrar os nomes na frase

o find() método do NameFinderMEclasse é usada para detectar os nomes no texto bruto passado a ela. Este método aceita uma variável String como parâmetro.

Chame este método passando o formato String da frase para este método.

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

Etapa 4: imprimir as extensões dos nomes na frase

o find() método do NameFinderMEclass retorna uma matriz de objetos do tipo Span. A classe chamada Span of theopennlp.tools.util pacote é usado para armazenar o start e end número inteiro de conjuntos.

Você pode armazenar os vãos retornados pelo find() na matriz Span e imprima-os, conforme mostrado no bloco de código a seguir.

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

NER Example

A seguir está o programa que lê a frase dada e reconhece a extensão dos nomes das pessoas nela. Salve este programa em um arquivo com o nomeNameFinderME_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 e execute o arquivo Java salvo no prompt de comando usando os seguintes comandos -

javac NameFinderME_Example.java 
java NameFinderME_Example

Ao ser executado, o programa acima lê a String fornecida (texto bruto), detecta os nomes das pessoas nela e exibe suas posições (spans), conforme mostrado abaixo.

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

Nomes junto com suas posições

o substring() método da classe String aceita o begin e a end offsetse retorna a respectiva string. Podemos usar esse método para imprimir os nomes e seus intervalos (posições) juntos, conforme mostrado no bloco de código a seguir.

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

A seguir está o programa para detectar os nomes do texto bruto fornecido e exibi-los junto com suas posições. Salve este programa em um arquivo com o nomeNameFinderSentences.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 e execute o arquivo Java salvo no prompt de comando usando os seguintes comandos -

javac NameFinderSentences.java 
java NameFinderSentences

Ao ser executado, o programa acima lê a String fornecida (texto bruto), detecta os nomes das pessoas nela e exibe suas posições (spans) conforme mostrado abaixo.

[0..1) person  Mike

Encontrar os nomes do local

Ao carregar vários modelos, você pode detectar várias entidades nomeadas. A seguir está um programa Java que carrega oen-ner-location.binmodelo e detecta os nomes dos locais na frase dada. Salve este programa em um arquivo com o nomeLocationFinder.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 e execute o arquivo Java salvo no prompt de comando usando os seguintes comandos -

javac LocationFinder.java 
java LocationFinder

Ao ser executado, o programa acima lê a String fornecida (texto bruto), detecta os nomes das pessoas nela e exibe suas posições (spans), conforme mostrado abaixo.

[4..5) location  Hyderabad

Probabilidade de NameFinder

o probs()método do NameFinderME classe é usada para obter as probabilidades da última sequência decodificada.

double[] probs = nameFinder.probs();

A seguir está o programa para imprimir as probabilidades. Salve este programa em um arquivo com o nomeTokenizerMEProbs.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 e execute o arquivo Java salvo no prompt de comando usando os seguintes comandos -

javac TokenizerMEProbs.java 
java TokenizerMEProbs

Ao ser executado, o programa acima lê a String fornecida, transforma as frases em token e as imprime. Além disso, também retorna as probabilidades da última sequência decodificada, conforme mostrado a seguir.

[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

Usando o OpenNLP, você também pode detectar as partes da fala de uma determinada frase e imprimi-las. Em vez do nome completo das classes gramaticais, o OpenNLP usa formas curtas de cada classe gramatical. A tabela a seguir indica as diversas partes dos discursos detectados pelo OpenNLP e seus significados.

Partes do discurso Significado da classe gramatical
NN Substantivo, singular ou massa
DT Determinante
VB Verbo, forma básica
VBD Verbo, pretérito
VBZ Verbo, terceira pessoa do singular presente
DENTRO Preposição ou conjunção subordinada
NNP Nome próprio, singular
PARA para
JJ Adjetivo

Marcando as partes da fala

Para marcar a classe gramatical de uma frase, o OpenNLP usa um modelo, um arquivo chamado en-posmaxent.bin. Este é um modelo predefinido que é treinado para marcar as classes gramaticais de um determinado texto bruto.

o POSTaggerME classe do opennlp.tools.postagpacote é usado para carregar este modelo e marcar a classe gramatical do texto bruto fornecido usando a biblioteca OpenNLP. Para fazer isso, você precisa -

  • Carregue o en-pos-maxent.bin modelo usando o POSModel classe.

  • Instancie o POSTaggerME classe.

  • Tokenize a frase.

  • Gere as tags usando tag() método.

  • Imprima os tokens e tags usando POSSample classe.

A seguir estão os passos a serem seguidos para escrever um programa que marca as partes do discurso no texto bruto fornecido usando o POSTaggerME classe.

Etapa 1: carregar o modelo

O modelo para marcação de POS é representado pela classe chamada POSModel, que pertence ao pacote opennlp.tools.postag.

Para carregar um modelo de tokenizer -

  • Criar um InputStream objeto do modelo (instancie o FileInputStream e passe o caminho do modelo no formato String para seu construtor).

  • Instancie o POSModel classe e passar no InputStream (objeto) do modelo como um parâmetro para seu construtor, conforme mostrado no seguinte bloco 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);

Etapa 2: instanciando a classe POSTaggerME

o POSTaggerME classe do pacote opennlp.tools.postagé usado para prever as classes gramaticais de um determinado texto bruto. Ele usa Entropia Máxima para tomar suas decisões.

Instancie esta classe e passe o objeto modelo criado na etapa anterior, conforme mostrado abaixo -

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

Etapa 3: tokenização da frase

o tokenize() método do whitespaceTokenizerclasse é usada para tokenizar o texto bruto passado a ela. Este método aceita uma variável String como parâmetro e retorna uma matriz de Strings (tokens).

Instancie o whitespaceTokenizer classe e invocar este método passando o formato String da frase para este método.

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

Etapa 4: Gerando as tags

o tag() método do whitespaceTokenizerclasse atribui tags POS para a frase de tokens. Este método aceita um array de tokens (String) como parâmetro e retorna a tag (array).

Invoque o tag() método passando os tokens gerados na etapa anterior para ele.

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

Etapa 5: imprimir os tokens e as tags

o POSSampleclasse representa a frase marcada com POS. Para instanciar essa classe, exigiríamos um array de tokens (do texto) e um array de tags.

o toString()método desta classe retorna a frase marcada. Instancie essa classe passando o token e as matrizes de tag criadas nas etapas anteriores e invoque seutoString() método, conforme mostrado no seguinte bloco de código.

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

Example

A seguir está o programa que marca as classes gramaticais em um determinado texto bruto. Salve este programa em um arquivo com o nomePosTaggerExample.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 e execute o arquivo Java salvo no prompt de comando usando os seguintes comandos -

javac PosTaggerExample.java 
java PosTaggerExample

Ao ser executado, o programa acima lê o texto fornecido e detecta as classes gramaticais dessas frases e as exibe, conforme mostrado abaixo.

Hi_NNP welcome_JJ to_TO Tutorialspoint_VB

Desempenho do POS Tagger

A seguir está o programa que marca as classes gramaticais de um determinado texto bruto. Ele também monitora o desempenho e exibe o desempenho do tagger. Salve este programa em um arquivo com o nomePosTagger_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 e execute o arquivo Java salvo no prompt de comando usando os seguintes comandos -

javac PosTaggerExample.java 
java PosTaggerExample

Na execução, o programa acima lê o texto fornecido, marca as classes gramaticais dessas frases e as exibe. Além disso, ele também monitora o desempenho do tagger POS e o exibe.

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

Probabilidade POS Tagger

o probs() método do POSTaggerME classe é usada para encontrar as probabilidades para cada tag da frase recentemente marcada.

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

A seguir está o programa que exibe as probabilidades para cada tag da última frase marcada. Salve este programa em um arquivo com o nomePosTaggerProbs.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 e execute o arquivo Java salvo no prompt de comando usando os seguintes comandos -

javac TokenizerMEProbs.java 
java TokenizerMEProbs

Ao ser executado, o programa acima lê o texto bruto fornecido, marca as classes gramaticais de cada token nele e os exibe. Além disso, ele também exibe as probabilidades para cada classe de palavras na frase dada, conforme mostrado abaixo.

Hi_NNP welcome_JJ to_TO Tutorialspoint_VB    
0.6416834779738033 
0.42983612874819177 
0.8584513635863117 
0.4394784478206072

Usando a API OpenNLP, você pode analisar as sentenças fornecidas. Neste capítulo, discutiremos como analisar texto bruto usando a API OpenNLP.

Análise de texto bruto usando a biblioteca OpenNLP

Para detectar as frases, o OpenNLP usa um modelo predefinido, um arquivo chamado en-parserchunking.bin. Este é um modelo predefinido que é treinado para analisar o texto bruto fornecido.

o Parser classe do opennlp.tools.Parser pacote é usado para manter os constituintes de análise e o ParserTool classe do opennlp.tools.cmdline.parser pacote é usado para analisar o conteúdo.

A seguir estão os passos a serem seguidos para escrever um programa que analisa o texto bruto fornecido usando o ParserTool classe.

Etapa 1: Carregando o modelo

O modelo de análise de texto é representado pela classe chamada ParserModel, que pertence ao pacote opennlp.tools.parser.

Para carregar um modelo de tokenizer -

  • Criar um InputStream objeto do modelo (instancie o FileInputStream e passe o caminho do modelo no formato String para seu construtor).

  • Instancie o ParserModel classe e passar no InputStream (objeto) do modelo como um parâmetro para seu construtor, conforme mostrado no bloco de código a seguir.

//Loading parser model 
InputStream inputStream = new FileInputStream(".../en-parserchunking.bin"); 
ParserModel model = new ParserModel(inputStream);

Etapa 2: Criação de um objeto da classe Parser

o Parser classe do pacote opennlp.tools.parserrepresenta uma estrutura de dados para manter os constituintes de análise. Você pode criar um objeto desta classe usando o método estáticocreate() método do ParserFactory classe.

Invoque o create() método do ParserFactory passando o objeto modelo criado na etapa anterior, conforme mostrado abaixo -

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

Etapa 3: análise da frase

o parseLine() método do ParserToolclasse é usada para analisar o texto bruto no OpenNLP. Este método aceita -

  • uma variável String que representa o texto a ser analisado.

  • um objeto analisador.

  • um inteiro que representa o número de análises a serem realizadas.

Invoque esse método passando os seguintes parâmetros para a frase: o objeto de análise criado nas etapas anteriores e um inteiro representando o número necessário de análises a serem realizadas.

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

Example

A seguir está o programa que analisa o texto bruto fornecido. Salve este programa em um arquivo com o nomeParserExample.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 e execute o arquivo Java salvo no prompt de comando usando os seguintes comandos -

javac ParserExample.java 
java ParserExample

Ao ser executado, o programa acima lê o texto bruto fornecido, analisa-o e exibe a seguinte saída -

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

Chunking uma frase refere-se a quebrar / dividir uma frase em partes de palavras, como grupos de palavras e grupos de verbos.

Chunking uma frase usando OpenNLP

Para detectar as frases, o OpenNLP usa um modelo, um arquivo chamado en-chunker.bin. Este é um modelo predefinido que é treinado para fragmentar as sentenças no texto bruto fornecido.

o opennlp.tools.chunker pacote contém as classes e interfaces que são usadas para encontrar anotações sintáticas não recursivas, como pedaços de frases nominais.

Você pode agrupar uma frase usando o método chunk() do ChunkerMEclasse. Este método aceita tokens de uma frase e tags POS como parâmetros. Portanto, antes de iniciar o processo de chunking, primeiro de tudo você precisa tokenizar a frase e gerar as tags POS das partes dela.

Para dividir uma frase usando a biblioteca OpenNLP, você precisa -

  • Tokenize a frase.

  • Gere tags de PDV para ele.

  • Carregue o en-chunker.bin modelo usando o ChunkerModel classe

  • Instancie o ChunkerME classe.

  • Separe as frases usando o chunk() método desta classe.

A seguir estão as etapas a serem seguidas para escrever um programa para separar frases do texto bruto fornecido.

Etapa 1: tokenização da frase

Tokenize as frases usando o tokenize() método do whitespaceTokenizer classe, conforme mostrado no bloco de código a seguir.

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

Etapa 2: Gerando as tags POS

Gere as tags POS da frase usando o tag() método do POSTaggerME classe, conforme mostrado no bloco de código a seguir.

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

Etapa 3: Carregando o modelo

O modelo para fragmentar uma frase é representado pela classe chamada ChunkerModel, que pertence ao pacote opennlp.tools.chunker.

Para carregar um modelo de detecção de frase -

  • Criar um InputStream objeto do modelo (instancie o FileInputStream e passe o caminho do modelo no formato String para seu construtor).

  • Instancie o ChunkerModel classe e passar no InputStream (objeto) do modelo como um parâmetro para seu construtor, conforme mostrado no seguinte bloco de código -

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

Etapa 4: instanciando a classe chunkerME

o chunkerME classe do pacote opennlp.tools.chunkercontém métodos para fragmentar as sentenças. Este é um chunker baseado em entropia máxima.

Instancie essa classe e transmita o objeto modelo criado na etapa anterior.

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

Etapa 5: dividir a frase

o chunk() método do ChunkerMEclasse é usada para dividir as sentenças no texto bruto que lhe foi passado. Este método aceita dois arrays String representando tokens e tags, como parâmetros.

Chame este método passando a matriz de token e a matriz de tag criadas nas etapas anteriores como parâmetros.

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

Example

A seguir está o programa para dividir as sentenças no texto bruto fornecido. Salve este programa em um arquivo com o nomeChunkerExample.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 e execute o arquivo Java salvo a partir do prompt de comando usando o seguinte comando -

javac ChunkerExample.java 
java ChunkerExample

Ao ser executado, o programa acima lê a String fornecida, separa as sentenças nela e as exibe conforme mostrado abaixo.

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

Detectando as posições dos tokens

Também podemos detectar as posições ou extensões dos pedaços usando o chunkAsSpans() método do ChunkerMEclasse. Este método retorna uma matriz de objetos do tipo Span. A classe chamada Span of theopennlp.tools.util pacote é usado para armazenar o start e end número inteiro de conjuntos.

Você pode armazenar os vãos retornados pelo chunkAsSpans() na matriz Span e imprima-os, conforme mostrado no bloco de código a seguir.

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

Example

A seguir está o programa que detecta as sentenças no texto bruto fornecido. Salve este programa em um arquivo com o nomeChunkerSpansEample.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 e execute o arquivo Java salvo no prompt de comando usando os seguintes comandos -

javac ChunkerSpansEample.java 
java ChunkerSpansEample

Ao ser executado, o programa acima lê a string fornecida e as extensões dos blocos nela, e exibe a seguinte saída -

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

Detecção de probabilidade de chunker

o probs() método do ChunkerME classe retorna as probabilidades da última sequência decodificada.

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

A seguir está o programa para imprimir as probabilidades da última sequência decodificada pelo chunker. Salve este programa em um arquivo com o nomeChunkerProbsExample.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 e execute o arquivo Java salvo no prompt de comando usando os seguintes comandos -

javac ChunkerProbsExample.java 
java ChunkerProbsExample

Ao ser executado, o programa acima lê a string fornecida, fragmenta-a e imprime as probabilidades da última sequência decodificada.

0.9592746040797778 
0.6883933131241501 
0.8830563473996004 
0.8951150529746051

O OpenNLP fornece uma interface de linha de comando (CLI) para realizar diferentes operações por meio da linha de comando. Neste capítulo, vamos dar alguns exemplos para mostrar como podemos usar a interface de linha de comando OpenNLP.

Tokenização

input.txt

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

Sintaxe

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

comando

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

resultado

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

Detecção de frases

input.txt

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

Sintaxe

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

comando

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

Resultado

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

Reconhecimento de entidade nomeada

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

Sintaxe

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

Comando

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

Resultado

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 da marcação de fala

Input.txt

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

Sintaxe

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

Comando

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

Resultado

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