OpenNLP - Guida rapida

La PNL è un insieme di strumenti utilizzati per ricavare informazioni utili e significative da fonti in linguaggio naturale come pagine web e documenti di testo.

Cos'è Open NLP?

Apache OpenNLPè una libreria Java open source che viene utilizzata per elaborare il testo in linguaggio naturale. È possibile creare un efficiente servizio di elaborazione del testo utilizzando questa libreria.

OpenNLP fornisce servizi come tokenizzazione, segmentazione di frasi, tagging di parti del discorso, estrazione di entità denominate, frammentazione, analisi e risoluzione di co-riferimento, ecc.

Caratteristiche di OpenNLP

Di seguito sono riportate le caratteristiche principali di OpenNLP:

  • Named Entity Recognition (NER) - Open NLP supporta NER, utilizzando il quale è possibile estrarre nomi di posizioni, persone e cose anche durante l'elaborazione delle query.

  • Summarize - Utilizzando il summarize è possibile riassumere paragrafi, articoli, documenti o la loro raccolta in PNL.

  • Searching - In OpenNLP, una determinata stringa di ricerca oi suoi sinonimi possono essere identificati in un determinato testo, anche se la parola data è alterata o scritta in modo errato.

  • Tagging (POS) - Il tagging in PNL viene utilizzato per dividere il testo in vari elementi grammaticali per ulteriori analisi.

  • Translation - In PNL, la traduzione aiuta a tradurre una lingua in un'altra.

  • Information grouping - Questa opzione in PNL raggruppa le informazioni testuali nel contenuto del documento, proprio come Parti del discorso.

  • Natural Language Generation - Viene utilizzato per generare informazioni da un database e automatizzare rapporti informativi come analisi meteorologiche o referti medici.

  • Feedback Analysis - Come suggerisce il nome, vengono raccolti vari tipi di feedback dalle persone, riguardo ai prodotti, dalla PNL per analizzare quanto bene il prodotto abbia successo nel conquistare i loro cuori.

  • Speech recognition - Sebbene sia difficile analizzare il linguaggio umano, la PNL ha alcune caratteristiche incorporate per questo requisito.

Apri l'API NLP

La libreria Apache OpenNLP fornisce classi e interfacce per eseguire varie attività di elaborazione del linguaggio naturale come il rilevamento di frasi, la tokenizzazione, la ricerca di un nome, l'etichettatura di parti del discorso, la suddivisione in blocchi di una frase, l'analisi, la risoluzione dei co-riferimenti e la categorizzazione dei documenti.

Oltre a queste attività, possiamo anche addestrare e valutare i nostri modelli per ognuna di queste attività.

OpenNLP CLI

Oltre alla libreria, OpenNLP fornisce anche un'interfaccia a riga di comando (CLI), in cui possiamo addestrare e valutare i modelli. Discuteremo questo argomento in dettaglio nell'ultimo capitolo di questo tutorial.

Apri modelli NLP

Per eseguire varie attività di NLP, OpenNLP fornisce una serie di modelli predefiniti. Questo set include modelli per diverse lingue.

Download dei modelli

È possibile seguire i passaggi indicati di seguito per scaricare i modelli predefiniti forniti da OpenNLP.

Step 1 - Aprire la pagina dell'indice dei modelli OpenNLP facendo clic sul seguente collegamento - http://opennlp.sourceforge.net/models-1.5/.

Step 2- Visitando il collegamento fornito, vedrai un elenco di componenti di varie lingue e i collegamenti per scaricarli. Qui puoi ottenere l'elenco di tutti i modelli predefiniti forniti da OpenNLP.

Scarica tutti questi modelli nella cartella C:/OpenNLP_models/>, cliccando sui rispettivi link. Tutti questi modelli dipendono dalla lingua e durante l'utilizzo di questi, è necessario assicurarsi che la lingua del modello corrisponda alla lingua del testo di input.

Storia di OpenNLP

  • Nel 2010, OpenNLP è entrato nell'incubazione di Apache.

  • Nel 2011 è stato rilasciato Apache OpenNLP 1.5.2 Incubating e nello stesso anno si è laureato come progetto Apache di primo livello.

  • Nel 2015, OpenNLP è stato rilasciato 1.6.0.

In questo capitolo, discuteremo di come configurare l'ambiente OpenNLP nel tuo sistema. Cominciamo con il processo di installazione.

Installazione di OpenNLP

Di seguito sono riportati i passaggi per il download Apache OpenNLP library nel tuo sistema.

Step 1 - Apri la home page di Apache OpenNLP facendo clic sul seguente collegamento - https://opennlp.apache.org/.

Step 2 - Ora fai clic sul file Downloadscollegamento. Facendo clic, verrai indirizzato a una pagina in cui puoi trovare vari mirror che ti reindirizzeranno alla directory di distribuzione di Apache Software Foundation.

Step 3- In questa pagina puoi trovare collegamenti per scaricare varie distribuzioni Apache. Sfogliali e trova la distribuzione OpenNLP e fai clic su di essa.

Step 4 - Facendo clic, verrai reindirizzato alla directory in cui puoi vedere l'indice della distribuzione OpenNLP, come mostrato di seguito.

Fare clic sull'ultima versione dalle distribuzioni disponibili.

Step 5- Ogni distribuzione fornisce file sorgente e binari della libreria OpenNLP in vari formati. Scarica i file sorgente e binari,apache-opennlp-1.6.0-bin.zip e apache-opennlp1.6.0-src.zip (per Windows).

Impostazione del percorso di classe

Dopo aver scaricato la libreria OpenNLP, è necessario impostare il suo percorso su bindirectory. Supponi di aver scaricato la libreria OpenNLP nell'unità E del tuo sistema.

Ora segui i passaggi indicati di seguito:

Step 1 - Fare clic con il pulsante destro del mouse su "Risorse del computer" e selezionare "Proprietà".

Step 2 - Fare clic sul pulsante "Variabili d'ambiente" nella scheda "Avanzate".

Step 3 - Seleziona il file path variabile e fare clic su Edit pulsante, come mostrato nello screenshot seguente.

Step 4 - Nella finestra Modifica variabile d'ambiente, fare clic su New e aggiungi il percorso per la directory OpenNLP E:\apache-opennlp-1.6.0\bin e fare clic su OK pulsante, come mostrato nello screenshot seguente.

Installazione di Eclipse

È possibile impostare l'ambiente Eclipse per la libreria OpenNLP, impostando il file Build path ai file JAR o utilizzando pom.xml.

Impostazione del percorso di compilazione dei file JAR

Segui i passaggi indicati di seguito per installare OpenNLP in Eclipse -

Step 1 - Assicurati di avere l'ambiente Eclipse installato nel tuo sistema.

Step 2- Apri Eclipse. Fare clic su File → Nuovo → Apri un nuovo progetto, come mostrato di seguito.

Step 3 - Otterrai il file New Projectprocedura guidata. In questa procedura guidata, seleziona il progetto Java e procedi facendo clic suNext pulsante.

Step 4 - Successivamente, otterrai il file New Java Project wizard. Qui, devi creare un nuovo progetto e fare clic suNext pulsante, come mostrato di seguito.

Step 5 - Dopo aver creato un nuovo progetto, fai clic destro su di esso, seleziona Build Path e fare clic Configure Build Path.

Step 6 - Successivamente, otterrai il file Java Build Pathprocedura guidata. Qui, fai clic suAdd External JARs pulsante, come mostrato di seguito.

Step 7 - Seleziona i file jar opennlp-tools-1.6.0.jar e opennlp-uima-1.6.0.jar situato nel lib cartella di apache-opennlp-1.6.0 folder.

Facendo clic su Open nella schermata sopra, i file selezionati verranno aggiunti alla tua libreria.

Facendo clic OK, aggiungerai correttamente i file JAR richiesti al progetto corrente e potrai verificare queste librerie aggiunte espandendo le Librerie referenziate, come mostrato di seguito.

Utilizzando pom.xml

Converti il ​​progetto in un progetto Maven e aggiungi il codice seguente al suo file 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>

In questo capitolo discuteremo delle classi e dei metodi che utilizzeremo nei capitoli successivi di questo tutorial.

Rilevamento di frasi

Classe SentenceModel

Questa classe rappresenta il modello predefinito che viene utilizzato per rilevare le frasi nel testo grezzo dato. Questa classe appartiene al pacchettoopennlp.tools.sentdetect.

Il costruttore di questa classe accetta un file InputStream oggetto del file del modello del rilevatore di frasi (en-sent.bin).

Classe SentenceDetectorME

Questa classe appartiene al pacchetto opennlp.tools.sentdetecte contiene metodi per dividere il testo grezzo in frasi. Questa classe utilizza un modello di entropia massima per valutare i caratteri di fine frase in una stringa per determinare se significano la fine di una frase.

Di seguito sono riportati i metodi importanti di questa classe.

S.No Metodi e descrizione
1

sentDetect()

Questo metodo viene utilizzato per rilevare le frasi nel testo grezzo che gli viene passato. Accetta una variabile String come parametro e restituisce un array String che contiene le frasi dal testo grezzo fornito.

2

sentPosDetect()

Questo metodo viene utilizzato per rilevare le posizioni delle frasi nel testo dato. Questo metodo accetta una variabile stringa, che rappresenta la frase e restituisce un array di oggetti del tipoSpan.

La classe denominata Span del opennlp.tools.util pacchetto viene utilizzato per memorizzare il numero intero iniziale e finale degli insiemi.

3

getSentenceProbabilities()

Questo metodo restituisce le probabilità associate alle chiamate più recenti a sentDetect() metodo.

Tokenizzazione

TokenizerModel classe

Questa classe rappresenta il modello predefinito utilizzato per tokenizzare la frase data. Questa classe appartiene al pacchettoopennlp.tools.tokenizer.

Il costruttore di questa classe accetta un file InputStream oggetto del file del modello di tokenizer (entoken.bin).

Classi

Per eseguire la tokenizzazione, la libreria OpenNLP fornisce tre classi principali. Tutte e tre le classi implementano l'interfaccia chiamataTokenizer.

S.No Classi e descrizione
1

SimpleTokenizer

Questa classe tokenizza il testo grezzo dato utilizzando classi di caratteri.

2

WhitespaceTokenizer

Questa classe utilizza gli spazi bianchi per tokenizzare il testo specificato.

3

TokenizerME

Questa classe converte il testo grezzo in token separati. Usa la massima entropia per prendere le sue decisioni.

Queste classi contengono i seguenti metodi.

S.No Metodi e descrizione
1

tokenize()

Questo metodo viene utilizzato per tokenizzare il testo grezzo. Questo metodo accetta una variabile String come parametro e restituisce una matrice di stringhe (token).

2

sentPosDetect()

Questo metodo viene utilizzato per ottenere le posizioni o gli intervalli dei token. Accetta la frase (o) il testo grezzo sotto forma di stringa e restituisce un array di oggetti del tipoSpan.

Oltre ai due metodi precedenti, il TokenizerME class ha l'estensione getTokenProbabilities() metodo.

S.No Metodi e descrizione
1

getTokenProbabilities()

Questo metodo viene utilizzato per ottenere le probabilità associate alle chiamate più recenti a tokenizePos() metodo.

NameEntityRecognition

TokenNameFinderModel classe

Questa classe rappresenta il modello predefinito che viene utilizzato per trovare le entità nominate nella frase data. Questa classe appartiene al pacchettoopennlp.tools.namefind.

Il costruttore di questa classe accetta un file InputStream oggetto del file del modello di ricerca del nome (enner-person.bin).

Classe NameFinderME

La classe appartiene al pacchetto opennlp.tools.namefinde contiene metodi per eseguire le attività NER. Questa classe utilizza un modello di entropia massima per trovare le entità nominate nel testo grezzo dato.

S.No Metodi e descrizione
1

find()

Questo metodo viene utilizzato per rilevare i nomi nel testo grezzo. Accetta una variabile String che rappresenta il testo grezzo come parametro e restituisce un array di oggetti del tipo Span.

2

probs()

Questo metodo viene utilizzato per ottenere le probabilità dell'ultima sequenza decodificata.

Trovare le parti del discorso

Classe POSModel

Questa classe rappresenta il modello predefinito che viene utilizzato per etichettare le parti del discorso della frase data. Questa classe appartiene al pacchettoopennlp.tools.postag.

Il costruttore di questa classe accetta un file InputStream oggetto del file del modello pos-tagger (enpos-maxent.bin).

Classe POSTaggerME

Questa classe appartiene al pacchetto opennlp.tools.postaged è usato per prevedere le parti del discorso del testo grezzo dato. Usa la massima entropia per prendere le sue decisioni.

S.No Metodi e descrizione
1

tag()

Questo metodo viene utilizzato per assegnare la frase dei token tag POS. Questo metodo accetta un array di token (String) come parametro e restituisce un tag (array).

2

getSentenceProbabilities()

Questo metodo viene utilizzato per ottenere le probabilità per ogni tag della frase contrassegnata di recente.

Analisi della frase

Classe ParserModel

Questa classe rappresenta il modello predefinito che viene utilizzato per analizzare la frase data. Questa classe appartiene al pacchettoopennlp.tools.parser.

Il costruttore di questa classe accetta un file InputStream oggetto del file modello parser (en-parserchunking.bin).

Classe Parser Factory

Questa classe appartiene al pacchetto opennlp.tools.parser ed è usato per creare parser.

S.No Metodi e descrizione
1

create()

Questo è un metodo statico e viene utilizzato per creare un oggetto parser. Questo metodo accetta l'oggetto Filestream del file del modello del parser.

Classe ParserTool

Questa classe appartiene al opennlp.tools.cmdline.parser pacchetto e, viene utilizzato per analizzare il contenuto.

S.No Metodi e descrizione
1

parseLine()

Questo metodo di ParserToolclass viene utilizzata per analizzare il testo grezzo in OpenNLP. Questo metodo accetta:

  • Una variabile String che rappresenta il testo da analizzare.
  • Un oggetto parser.
  • Un numero intero che rappresenta il numero di analisi da eseguire.

Chunking

Classe ChunkerModel

Questa classe rappresenta il modello predefinito utilizzato per dividere una frase in parti più piccole. Questa classe appartiene al pacchettoopennlp.tools.chunker.

Il costruttore di questa classe accetta un file InputStream oggetto del chunker file di modello (enchunker.bin).

Classe ChunkerME

Questa classe appartiene al pacchetto denominato opennlp.tools.chunker ed è usato per dividere la frase data in parti più piccole.

S.No Metodi e descrizione
1

chunk()

Questo metodo viene utilizzato per dividere la frase data in parti più piccole. Accetta i segni di una frase eParti Of Stag peech come parametri.

2

probs()

Questo metodo restituisce le probabilità dell'ultima sequenza decodificata.

Durante l'elaborazione di un linguaggio naturale, decidere l'inizio e la fine delle frasi è uno dei problemi da affrontare. Questo processo è noto comeSentence Boundario Disambiguazione (SBD) o semplicemente rottura di una frase.

Le tecniche che usiamo per rilevare le frasi nel testo dato, dipendono dalla lingua del testo.

Rilevamento di frasi tramite Java

Possiamo rilevare le frasi nel testo dato in Java usando, espressioni regolari e una serie di semplici regole.

Ad esempio, supponiamo che un punto, un punto interrogativo o un punto esclamativo termini una frase nel testo dato, quindi possiamo dividere la frase usando il split() metodo del Stringclasse. Qui dobbiamo passare un'espressione regolare in formato String.

Di seguito è riportato il programma che determina le frasi in un dato testo utilizzando espressioni regolari Java (split method). Salva questo programma in un file con il 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);      
   } 
}

Compilare ed eseguire il file java salvato dal prompt dei comandi utilizzando i seguenti comandi.

javac SentenceDetection_RE.java 
java SentenceDetection_RE

All'esecuzione, il programma di cui sopra crea un documento PDF che mostra il seguente messaggio.

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

Rilevamento di frasi tramite OpenNLP

Per rilevare le frasi, OpenNLP utilizza un modello predefinito, un file denominato en-sent.bin. Questo modello predefinito è addestrato per rilevare frasi in un dato testo grezzo.

Il opennlp.tools.sentdetect Il pacchetto contiene le classi e le interfacce utilizzate per eseguire l'attività di rilevamento delle frasi.

Per rilevare una frase utilizzando la libreria OpenNLP, è necessario:

  • Carica il file en-sent.bin modello utilizzando il SentenceModel classe

  • Istanziare il file SentenceDetectorME classe.

  • Rileva le frasi usando il sentDetect() metodo di questa classe.

Di seguito sono riportati i passaggi da seguire per scrivere un programma che rilevi le frasi dal testo grezzo dato.

Passaggio 1: caricamento del modello

Il modello per il rilevamento della frase è rappresentato dalla classe denominata SentenceModel, che appartiene al pacchetto opennlp.tools.sentdetect.

Per caricare un modello di rilevamento della frase:

  • Creare un InputStream oggetto del modello (creare un'istanza di FileInputStream e passare il percorso del modello in formato String al suo costruttore).

  • Istanziare il file SentenceModel class e passare il InputStream (oggetto) del modello come parametro del suo costruttore come mostrato nel seguente blocco di codice -

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

Passaggio 2: creazione di un'istanza della classe SentenceDetectorME

Il SentenceDetectorME classe del pacchetto opennlp.tools.sentdetectcontiene metodi per dividere il testo grezzo in frasi. Questa classe utilizza il modello Entropia massima per valutare i caratteri di fine frase in una stringa per determinare se significano la fine di una frase.

Istanziare questa classe e passare l'oggetto modello creato nel passaggio precedente, come mostrato di seguito.

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

Passaggio 3: rilevamento della frase

Il sentDetect() metodo del SentenceDetectorMEclass è usata per rilevare le frasi nel testo grezzo che gli è stato passato. Questo metodo accetta una variabile String come parametro.

Richiamare questo metodo passando il formato String della frase a questo metodo.

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

Example

Di seguito è riportato il programma che rileva le frasi in un dato testo grezzo. Salva questo programma in un file con 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);  
   } 
}

Compilare ed eseguire il file Java salvato dal prompt dei comandi utilizzando i seguenti comandi:

javac SentenceDetectorME.java 
java SentenceDetectorME

In esecuzione, il programma precedente legge la stringa data e rileva le frasi in essa contenute e visualizza il seguente output.

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

Rilevamento delle posizioni delle frasi

Possiamo anche rilevare le posizioni delle frasi utilizzando il metodo sentPosDetect () di SentenceDetectorME class.

Di seguito sono riportati i passaggi da seguire per scrivere un programma che rilevi le posizioni delle frasi dal testo grezzo dato.

Passaggio 1: caricamento del modello

Il modello per il rilevamento della frase è rappresentato dalla classe denominata SentenceModel, che appartiene al pacchetto opennlp.tools.sentdetect.

Per caricare un modello di rilevamento della frase:

  • Creare un InputStream oggetto del modello (creare un'istanza di FileInputStream e passare il percorso del modello in formato String al suo costruttore).

  • Istanziare il file SentenceModel class e passare il InputStream (oggetto) del modello come parametro del suo costruttore, come mostrato nel seguente blocco di codice.

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

Passaggio 2: creazione di un'istanza della classe SentenceDetectorME

Il SentenceDetectorME classe del pacchetto opennlp.tools.sentdetectcontiene metodi per dividere il testo grezzo in frasi. Questa classe utilizza il modello Entropia massima per valutare i caratteri di fine frase in una stringa per determinare se significano la fine di una frase.

Crea un'istanza di questa classe e passa l'oggetto modello creato nel passaggio precedente.

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

Passaggio 3: rilevamento della posizione della frase

Il sentPosDetect() metodo del SentenceDetectorMEclass viene utilizzata per rilevare le posizioni delle frasi nel testo grezzo passato ad essa. Questo metodo accetta una variabile String come parametro.

Richiamare questo metodo passando il formato String della frase come parametro a questo metodo.

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

Passaggio 4: stampa degli intervalli delle frasi

Il sentPosDetect() metodo del SentenceDetectorME class restituisce un array di oggetti del tipo Span. La classe denominata Span of theopennlp.tools.util pacchetto viene utilizzato per memorizzare il numero intero iniziale e finale degli insiemi.

È possibile memorizzare gli intervalli restituiti da sentPosDetect() nell'array Span e stamparli, come mostrato nel seguente blocco di codice.

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

Example

Di seguito è riportato il programma che rileva le frasi nel testo grezzo fornito. Salva questo programma in un file con 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);  
   } 
}

Compilare ed eseguire il file Java salvato dal prompt dei comandi utilizzando i seguenti comandi:

javac SentencePosDetection.java 
java SentencePosDetection

In esecuzione, il programma precedente legge la stringa data e rileva le frasi in essa contenute e visualizza il seguente output.

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

Frasi insieme alle loro posizioni

Il substring() metodo della classe String accetta il begin e il end offsetse restituisce la rispettiva stringa. Possiamo usare questo metodo per stampare le frasi e le loro estensioni (posizioni) insieme, come mostrato nel seguente blocco di codice.

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

Di seguito è riportato il programma per rilevare le frasi dal testo grezzo dato e visualizzarle insieme alle loro posizioni. Salva questo programma in un file con 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);  
   } 
}

Compilare ed eseguire il file Java salvato dal prompt dei comandi utilizzando i seguenti comandi:

javac SentencesAndPosDetection.java 
java SentencesAndPosDetection

In esecuzione, il programma precedente legge la stringa data e rileva le frasi insieme alle loro posizioni e visualizza il seguente output.

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

Rilevamento della probabilità di frase

Il getSentenceProbabilities() metodo del SentenceDetectorME class restituisce le probabilità associate alle chiamate più recenti al metodo sentDetect ().

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

Di seguito è riportato il programma per stampare le probabilità associate alle chiamate al metodo sentDetect (). Salva questo programma in un file con il 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]); 
   } 
}

Compilare ed eseguire il file Java salvato dal prompt dei comandi utilizzando i seguenti comandi:

javac SentenceDetectionMEProbs.java 
java SentenceDetectionMEProbs

All'esecuzione, il programma di cui sopra legge la stringa data e rileva le frasi e le stampa. Inoltre, restituisce anche le probabilità associate alle chiamate più recenti al metodo sentDetect (), come mostrato di seguito.

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

Il processo di sminuzzare la frase data in parti più piccole (gettoni) è noto come tokenization. In generale, il testo non elaborato fornito è tokenizzato in base a un insieme di delimitatori (principalmente spazi bianchi).

La tokenizzazione viene utilizzata in attività come il controllo ortografico, l'elaborazione di ricerche, l'identificazione di parti del discorso, il rilevamento di frasi, la classificazione dei documenti, ecc.

Tokenizzazione utilizzando OpenNLP

Il opennlp.tools.tokenize pacchetto contiene le classi e le interfacce utilizzate per eseguire la tokenizzazione.

Per tokenizzare le frasi date in frammenti più semplici, la libreria OpenNLP fornisce tre classi differenti:

  • SimpleTokenizer - Questa classe tokenizza il testo grezzo dato usando classi di caratteri.

  • WhitespaceTokenizer - Questa classe utilizza gli spazi bianchi per tokenizzare il testo specificato.

  • TokenizerME- Questa classe converte il testo grezzo in token separati. Usa la massima entropia per prendere le sue decisioni.

SimpleTokenizer

Per tokenizzare una frase usando il SimpleTokenizer classe, devi -

  • Crea un oggetto della rispettiva classe.

  • Tokenizza la frase usando il tokenize() metodo.

  • Stampa i gettoni.

Di seguito sono riportati i passaggi da seguire per scrivere un programma che tokenizza il testo grezzo dato.

Step 1 - Istanziare la rispettiva classe

In entrambe le classi non sono disponibili costruttori per istanziarle. Pertanto, dobbiamo creare oggetti di queste classi utilizzando la variabile staticaINSTANCE.

SimpleTokenizer tokenizer = SimpleTokenizer.INSTANCE;

Step 2 - Tokenizza le frasi

Entrambe queste classi contengono un metodo chiamato tokenize(). Questo metodo accetta un testo non elaborato in formato String. All'invocazione, tokenizza la stringa data e restituisce un array di stringhe (token).

Tokenizza la frase usando il tokenizer() metodo come mostrato di seguito.

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

Step 3 - Stampa i gettoni

Dopo aver tokenizzato la frase, puoi stampare i token usando for loop, come mostrato di seguito.

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

Example

Di seguito è riportato il programma che tokenizza la frase data utilizzando la classe SimpleTokenizer. Salva questo programma in un file con il 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);  
      }       
   }  
}

Compilare ed eseguire il file Java salvato dal prompt dei comandi utilizzando i seguenti comandi:

javac SimpleTokenizerExample.java 
java SimpleTokenizerExample

All'esecuzione, il programma precedente legge la stringa data (testo grezzo), la tokenizza e visualizza il seguente output:

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

WhitespaceTokenizer

Per tokenizzare una frase usando il WhitespaceTokenizer classe, devi -

  • Crea un oggetto della rispettiva classe.

  • Tokenizza la frase usando il tokenize() metodo.

  • Stampa i gettoni.

Di seguito sono riportati i passaggi da seguire per scrivere un programma che tokenizza il testo grezzo dato.

Step 1 - Istanziare la rispettiva classe

In entrambe le classi non sono disponibili costruttori per istanziarle. Pertanto, dobbiamo creare oggetti di queste classi utilizzando la variabile staticaINSTANCE.

WhitespaceTokenizer tokenizer = WhitespaceTokenizer.INSTANCE;

Step 2 - Tokenizza le frasi

Entrambe queste classi contengono un metodo chiamato tokenize(). Questo metodo accetta un testo non elaborato in formato String. All'invocazione, tokenizza la stringa data e restituisce un array di stringhe (token).

Tokenizza la frase usando il tokenizer() metodo come mostrato di seguito.

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

Step 3 - Stampa i gettoni

Dopo aver tokenizzato la frase, puoi stampare i token usando for loop, come mostrato di seguito.

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

Example

Di seguito è riportato il programma che tokenizza la frase data utilizzando il WhitespaceTokenizerclasse. Salva questo programma in un file con il 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);        
   } 
}

Compilare ed eseguire il file Java salvato dal prompt dei comandi utilizzando i seguenti comandi:

javac WhitespaceTokenizerExample.java 
java WhitespaceTokenizerExample

Durante l'esecuzione, il programma precedente legge la stringa data (testo grezzo), la tokenizza e visualizza il seguente output.

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

TokenizerME classe

OpenNLP utilizza anche un modello predefinito, un file denominato de-token.bin, per tokenizzare le frasi. È addestrato per tokenizzare le frasi in un dato testo grezzo.

Il TokenizerME classe di opennlp.tools.tokenizerpacchetto viene utilizzato per caricare questo modello e tokenizzare il testo non elaborato specificato utilizzando la libreria OpenNLP. Per fare ciò, devi:

  • Carica il file en-token.bin modello utilizzando il TokenizerModel classe.

  • Istanziare il file TokenizerME classe.

  • Tokenizza le frasi usando il tokenize() metodo di questa classe.

Di seguito sono riportati i passaggi da seguire per scrivere un programma che tokenizza le frasi dal testo grezzo dato utilizzando il TokenizerME classe.

Step 1 - Caricamento del modello

Il modello per la tokenizzazione è rappresentato dalla classe denominata TokenizerModel, che appartiene al pacchetto opennlp.tools.tokenize.

Per caricare un modello di tokenizer:

  • Creare un InputStream oggetto del modello (creare un'istanza di FileInputStream e passare il percorso del modello in formato String al suo costruttore).

  • Istanziare il file TokenizerModel class e passare il InputStream (oggetto) del modello come parametro del suo costruttore, come mostrato nel seguente blocco di codice.

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

Step 2 - Creazione di istanze della classe TokenizerME

Il TokenizerME classe del pacchetto opennlp.tools.tokenizecontiene metodi per tagliare il testo grezzo in parti più piccole (token). Usa la massima entropia per prendere le sue decisioni.

Istanziare questa classe e passare l'oggetto modello creato nel passaggio precedente come mostrato di seguito.

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

Step 3 - Tokenizzare la frase

Il tokenize() metodo del TokenizerMEclass è usata per tokenizzare il testo grezzo che gli è stato passato. Questo metodo accetta una variabile String come parametro e restituisce una matrice di stringhe (token).

Richiamare questo metodo passando il formato String della frase a questo metodo, come segue.

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

Example

Di seguito è riportato il programma che tokenizza il testo grezzo dato. Salva questo programma in un file con il 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); 
   } 
}

Compilare ed eseguire il file Java salvato dal prompt dei comandi utilizzando i seguenti comandi:

javac TokenizerMEExample.java 
java TokenizerMEExample

All'esecuzione, il programma sopra legge la stringa data e rileva le frasi in essa e visualizza il seguente output:

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

Recupero delle posizioni dei token

Possiamo anche ottenere le posizioni o spans dei token utilizzando l'estensione tokenizePos()metodo. Questo è il metodo dell'interfaccia Tokenizer del pacchettoopennlp.tools.tokenize. Poiché tutte le (tre) classi Tokenizer implementano questa interfaccia, puoi trovare questo metodo in tutte.

Questo metodo accetta la frase o il testo grezzo sotto forma di stringa e restituisce un array di oggetti del tipo Span.

Puoi ottenere le posizioni dei gettoni usando il tokenizePos() metodo, come segue:

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

Stampa delle posizioni (intervalli)

La classe denominata Span del opennlp.tools.util pacchetto viene utilizzato per memorizzare il numero intero iniziale e finale degli insiemi.

È possibile memorizzare gli intervalli restituiti da tokenizePos() nell'array Span e stamparli, come mostrato nel seguente blocco di codice.

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

Stampa di gettoni e loro posizioni insieme

Il substring() metodo della classe String accetta il begin e il endcompensa e restituisce la rispettiva stringa. Possiamo usare questo metodo per stampare i token e le loro estensioni (posizioni) insieme, come mostrato nel seguente blocco di codice.

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

Example(SimpleTokenizer)

Di seguito è riportato il programma che recupera gli intervalli di token del testo grezzo utilizzando l'estensione SimpleTokenizerclasse. Stampa anche i gettoni insieme alle loro posizioni. Salva questo programma in un file con 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()));          
   } 
}

Compilare ed eseguire il file Java salvato dal prompt dei comandi utilizzando i seguenti comandi:

javac SimpleTokenizerSpans.java 
java SimpleTokenizerSpans

All'esecuzione, il programma precedente legge la stringa data (testo grezzo), la tokenizza e visualizza il seguente output:

[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)

Di seguito è riportato il programma che recupera gli intervalli di token del testo grezzo utilizzando l'estensione WhitespaceTokenizerclasse. Stampa anche i gettoni insieme alle loro posizioni. Salva questo programma in un file con il 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()));        
   } 
}

Compilare ed eseguire il file java salvato dal prompt dei comandi utilizzando i seguenti comandi

javac WhitespaceTokenizerSpans.java 
java WhitespaceTokenizerSpans

Durante l'esecuzione, il programma precedente legge la stringa data (testo grezzo), la tokenizza e visualizza il seguente output.

[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)

Di seguito è riportato il programma che recupera gli intervalli di token del testo grezzo utilizzando l'estensione TokenizerMEclasse. Stampa anche i gettoni insieme alle loro posizioni. Salva questo programma in un file con il 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()));      
   } 
}

Compilare ed eseguire il file Java salvato dal prompt dei comandi utilizzando i seguenti comandi:

javac TokenizerMESpans.java 
java TokenizerMESpans

All'esecuzione, il programma precedente legge la stringa data (testo grezzo), la tokenizza e visualizza il seguente output:

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

Probabilità del tokenizzatore

Il metodo getTokenProbabilities () della classe TokenizerME viene utilizzato per ottenere le probabilità associate alle chiamate più recenti al metodo tokenizePos ().

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

Di seguito è riportato il programma per stampare le probabilità associate alle chiamate al metodo tokenizePos (). Salva questo programma in un file con il 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]);          
   } 
}

Compilare ed eseguire il file Java salvato dal prompt dei comandi utilizzando i seguenti comandi:

javac TokenizerMEProbs.java 
java TokenizerMEProbs

All'esecuzione, il programma precedente legge la stringa data e tokenizza le frasi e le stampa. Inoltre, restituisce anche le probabilità associate alle chiamate più recenti al metodo 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

Il processo di ricerca di nomi, persone, luoghi e altre entità da un determinato testo è noto come Named Entity Rriconoscimento (NER). In questo capitolo, discuteremo come eseguire NER tramite il programma Java utilizzando la libreria OpenNLP.

Riconoscimento di entità denominate utilizzando NLP aperto

Per eseguire varie attività NER, OpenNLP utilizza diversi modelli predefiniti, ovvero en-nerdate.bn, en-ner-location.bin, en-ner-organization.bin, en-ner-person.bin ed en-ner-time. bidone. Tutti questi file sono modelli predefiniti addestrati per rilevare le rispettive entità in un dato testo grezzo.

Il opennlp.tools.namefindIl pacchetto contiene le classi e le interfacce utilizzate per eseguire l'attività NER. Per eseguire attività NER utilizzando la libreria OpenNLP, è necessario:

  • Caricare il rispettivo modello utilizzando il file TokenNameFinderModel classe.

  • Istanziare il file NameFinder classe.

  • Trova i nomi e stampali.

Di seguito sono riportati i passaggi da seguire per scrivere un programma che rilevi le entità del nome da un dato testo grezzo.

Passaggio 1: caricamento del modello

Il modello per il rilevamento della frase è rappresentato dalla classe denominata TokenNameFinderModel, che appartiene al pacchetto opennlp.tools.namefind.

Per caricare un modello NER -

  • Creare un InputStream oggetto del modello (creare un'istanza di FileInputStream e passare il percorso del modello NER appropriato in formato String al suo costruttore).

  • Istanziare il file TokenNameFinderModel class e passare il InputStream (oggetto) del modello come parametro del suo costruttore, come mostrato nel seguente blocco di codice.

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

Passaggio 2: creazione di un'istanza della classe NameFinderME

Il NameFinderME classe del pacchetto opennlp.tools.namefindcontiene metodi per eseguire le attività NER. Questa classe utilizza il modello Entropia massima per trovare le entità nominate nel testo grezzo fornito.

Crea un'istanza di questa classe e passa l'oggetto modello creato nel passaggio precedente come mostrato di seguito:

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

Passaggio 3: trovare i nomi nella frase

Il find() metodo del NameFinderMEclass è usata per rilevare i nomi nel testo grezzo passato ad essa. Questo metodo accetta una variabile String come parametro.

Richiamare questo metodo passando il formato String della frase a questo metodo.

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

Passaggio 4: stampa degli intervalli dei nomi nella frase

Il find() metodo del NameFinderMEclass restituisce un array di oggetti del tipo Span. La classe denominata Span of theopennlp.tools.util pacchetto viene utilizzato per memorizzare il file start e end numero intero di insiemi.

È possibile memorizzare gli intervalli restituiti da find() nell'array Span e stamparli, come mostrato nel seguente blocco di codice.

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

NER Example

Di seguito è riportato il programma che legge la frase data e riconosce gli intervalli dei nomi delle persone in essa contenuti. Salva questo programma in un file con il 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());    
   }    
}

Compilare ed eseguire il file Java salvato dal prompt dei comandi utilizzando i seguenti comandi:

javac NameFinderME_Example.java 
java NameFinderME_Example

All'esecuzione, il programma di cui sopra legge la stringa data (testo grezzo), rileva i nomi delle persone in essa e visualizza le loro posizioni (intervalli), come mostrato di seguito.

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

Nomi insieme alle loro posizioni

Il substring() metodo della classe String accetta il begin e il end offsetse restituisce la rispettiva stringa. Possiamo usare questo metodo per stampare i nomi e le loro estensioni (posizioni) insieme, come mostrato nel seguente blocco di codice.

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

Di seguito è riportato il programma per rilevare i nomi dal testo grezzo fornito e visualizzarli insieme alle loro posizioni. Salva questo programma in un file con il 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()]);      
   }    
}

Compilare ed eseguire il file Java salvato dal prompt dei comandi utilizzando i seguenti comandi:

javac NameFinderSentences.java 
java NameFinderSentences

All'esecuzione, il programma precedente legge la stringa data (testo grezzo), rileva i nomi delle persone in essa contenute e visualizza le loro posizioni (intervalli) come mostrato di seguito.

[0..1) person  Mike

Trovare i nomi della posizione

Caricando vari modelli, è possibile rilevare varie entità con nome. Di seguito è riportato un programma Java che carica il fileen-ner-location.binmodel e rileva i nomi delle posizioni nella frase data. Salva questo programma in un file con il 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()]); 
   }    
}

Compilare ed eseguire il file Java salvato dal prompt dei comandi utilizzando i seguenti comandi:

javac LocationFinder.java 
java LocationFinder

All'esecuzione, il programma di cui sopra legge la stringa data (testo grezzo), rileva i nomi delle persone in essa e visualizza le loro posizioni (intervalli), come mostrato di seguito.

[4..5) location  Hyderabad

Probabilità di NameFinder

Il probs()metodo del NameFinderME class viene utilizzata per ottenere le probabilità dell'ultima sequenza decodificata.

double[] probs = nameFinder.probs();

Di seguito è riportato il programma per stampare le probabilità. Salva questo programma in un file con il 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]);          
   } 
}

Compilare ed eseguire il file Java salvato dal prompt dei comandi utilizzando i seguenti comandi:

javac TokenizerMEProbs.java 
java TokenizerMEProbs

Durante l'esecuzione, il programma precedente legge la stringa data, tokenizza le frasi e le stampa. Inoltre, restituisce anche le probabilità dell'ultima sequenza decodificata, come mostrato di seguito.

[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

Utilizzando OpenNLP, puoi anche rilevare le parti del discorso di una determinata frase e stamparle. Invece del nome completo delle parti del discorso, OpenNLP utilizza forme brevi di ciascuna parte del discorso. La tabella seguente indica le varie parti dei discorsi rilevati da OpenNLP e il loro significato.

Parti del discorso Significato delle parti del discorso
NN Sostantivo, singolare o massa
DT Determinatore
VB Verbo, forma base
VBD Verbo, passato
VBZ Verbo, terza persona singolare presente
IN Preposizione o congiunzione subordinata
NNP Nome proprio, singolare
PER per
JJ Aggettivo

Contrassegnare le parti del discorso

Per contrassegnare le parti del discorso di una frase, OpenNLP utilizza un modello, un file denominato en-posmaxent.bin. Questo è un modello predefinito addestrato per etichettare le parti del discorso del testo grezzo dato.

Il POSTaggerME classe di opennlp.tools.postagpacchetto viene utilizzato per caricare questo modello e contrassegnare le parti del discorso del testo non elaborato specificato utilizzando la libreria OpenNLP. Per fare ciò, devi:

  • Carica il file en-pos-maxent.bin modello utilizzando il POSModel classe.

  • Istanziare il file POSTaggerME classe.

  • Tokenizza la frase.

  • Genera i tag usando tag() metodo.

  • Stampa i token e i tag utilizzando POSSample classe.

Di seguito sono riportati i passaggi da seguire per scrivere un programma che contrassegna le parti del discorso nel testo grezzo dato utilizzando il POSTaggerME classe.

Passaggio 1: carica il modello

Il modello per il tagging POS è rappresentato dalla classe denominata POSModel, che appartiene al pacchetto opennlp.tools.postag.

Per caricare un modello di tokenizer:

  • Creare un InputStream oggetto del modello (creare un'istanza di FileInputStream e passare il percorso del modello in formato String al suo costruttore).

  • Istanziare il file POSModel class e passare il InputStream (oggetto) del modello come parametro del suo costruttore, come mostrato nel seguente blocco di codice:

//Loading Parts of speech-maxent model 
InputStream inputStream = new FileInputStream("C:/OpenNLP_models/en-pos-maxent.bin"); 
POSModel model = new POSModel(inputStream);

Passaggio 2: creazione di un'istanza della classe POSTaggerME

Il POSTaggerME classe del pacchetto opennlp.tools.postagviene utilizzato per prevedere le parti del discorso del testo grezzo specificato. Usa la massima entropia per prendere le sue decisioni.

Crea un'istanza di questa classe e passa l'oggetto modello creato nel passaggio precedente, come mostrato di seguito:

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

Passaggio 3: tokenizzazione della frase

Il tokenize() metodo del whitespaceTokenizerclass è usata per tokenizzare il testo grezzo che gli è stato passato. Questo metodo accetta una variabile String come parametro e restituisce una matrice di stringhe (token).

Istanziare il file whitespaceTokenizer class e invocano questo metodo passando il formato String della frase a questo metodo.

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

Passaggio 4: generazione dei tag

Il tag() metodo del whitespaceTokenizerclass assegna i tag POS alla frase dei token. Questo metodo accetta un array di token (String) come parametro e restituisce tag (array).

Invoca il file tag() passandogli i token generati nel passaggio precedente.

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

Passaggio 5: stampa dei token e dei tag

Il POSSampleclass rappresenta la frase con tag POS. Per istanziare questa classe, avremmo bisogno di un array di token (del testo) e di un array di tag.

Il toString()Il metodo di questa classe restituisce la frase contrassegnata. Creare un'istanza di questa classe passando il token e gli array di tag creati nei passaggi precedenti e richiamarlitoString() metodo, come mostrato nel seguente blocco di codice.

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

Example

Di seguito è riportato il programma che contrassegna le parti del discorso in un dato testo grezzo. Salva questo programma in un file con il 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()); 
   
   } 
}

Compilare ed eseguire il file Java salvato dal prompt dei comandi utilizzando i seguenti comandi:

javac PosTaggerExample.java 
java PosTaggerExample

All'esecuzione, il programma di cui sopra legge il testo dato e rileva le parti del discorso di queste frasi e le visualizza, come mostrato di seguito.

Hi_NNP welcome_JJ to_TO Tutorialspoint_VB

POS Tagger Performance

Di seguito è riportato il programma che contrassegna le parti del discorso di un dato testo grezzo. Inoltre monitora le prestazioni e mostra le prestazioni del tagger. Salva questo programma in un file con il 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();      
   } 
}

Compilare ed eseguire il file Java salvato dal prompt dei comandi utilizzando i seguenti comandi:

javac PosTaggerExample.java 
java PosTaggerExample

All'esecuzione, il programma precedente legge il testo dato e contrassegna le parti del discorso di queste frasi e le visualizza. Inoltre, monitora anche le prestazioni del tagger POS e le visualizza.

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

Probabilità di tagger POS

Il probs() metodo del POSTaggerME class viene utilizzata per trovare le probabilità per ogni tag della frase contrassegnata di recente.

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

Di seguito è riportato il programma che mostra le probabilità per ogni tag dell'ultima frase contrassegnata. Salva questo programma in un file con il 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]); 
   } 
}

Compilare ed eseguire il file Java salvato dal prompt dei comandi utilizzando i seguenti comandi:

javac TokenizerMEProbs.java 
java TokenizerMEProbs

Durante l'esecuzione, il programma precedente legge il testo non elaborato fornito, contrassegna le parti del discorso di ciascun token in esso e le visualizza. Inoltre, mostra anche le probabilità per ciascuna parte del discorso nella frase data, come mostrato di seguito.

Hi_NNP welcome_JJ to_TO Tutorialspoint_VB    
0.6416834779738033 
0.42983612874819177 
0.8584513635863117 
0.4394784478206072

Utilizzando OpenNLP API, puoi analizzare le frasi fornite. In questo capitolo, discuteremo come analizzare il testo grezzo utilizzando l'API OpenNLP.

Analisi del testo grezzo utilizzando la libreria OpenNLP

Per rilevare le frasi, OpenNLP utilizza un modello predefinito, un file denominato en-parserchunking.bin. Questo è un modello predefinito addestrato per analizzare il testo non elaborato specificato.

Il Parser classe di opennlp.tools.Parser pacchetto viene utilizzato per contenere i componenti di analisi e il file ParserTool classe di opennlp.tools.cmdline.parser pacchetto viene utilizzato per analizzare il contenuto.

Di seguito sono riportati i passaggi da seguire per scrivere un programma che analizzi il testo non elaborato specificato utilizzando l'estensione ParserTool classe.

Passaggio 1: caricamento del modello

Il modello per l'analisi del testo è rappresentato dalla classe denominata ParserModel, che appartiene al pacchetto opennlp.tools.parser.

Per caricare un modello di tokenizer:

  • Creare un InputStream oggetto del modello (creare un'istanza di FileInputStream e passare il percorso del modello in formato String al suo costruttore).

  • Istanziare il file ParserModel class e passare il InputStream (oggetto) del modello come parametro del suo costruttore, come mostrato nel seguente blocco di codice.

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

Passaggio 2: creazione di un oggetto della classe Parser

Il Parser classe del pacchetto opennlp.tools.parserrappresenta una struttura di dati per contenere i componenti di analisi. Puoi creare un oggetto di questa classe usando il file staticcreate() metodo del ParserFactory classe.

Invoca il file create() metodo del ParserFactory passando l'oggetto modello creato nel passaggio precedente, come mostrato di seguito -

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

Passaggio 3: analisi della frase

Il parseLine() metodo del ParserToolclass viene utilizzata per analizzare il testo grezzo in OpenNLP. Questo metodo accetta:

  • una variabile String che rappresenta il testo da analizzare.

  • un oggetto parser.

  • un numero intero che rappresenta il numero di analisi da eseguire.

Richiamare questo metodo passando alla frase i seguenti parametri: l'oggetto di analisi creato nei passaggi precedenti e un numero intero che rappresenta il numero di analisi richiesto da eseguire.

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

Example

Di seguito è riportato il programma che analizza il testo grezzo fornito. Salva questo programma in un file con il 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();          
   } 
}

Compilare ed eseguire il file Java salvato dal prompt dei comandi utilizzando i seguenti comandi:

javac ParserExample.java 
java ParserExample

All'esecuzione, il programma precedente legge il testo grezzo fornito, lo analizza e visualizza il seguente output:

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

Suddividere una frase si riferisce alla rottura / divisione di una frase in parti di parole come gruppi di parole e gruppi di verbi.

Suddivisione di una frase utilizzando OpenNLP

Per rilevare le frasi, OpenNLP utilizza un modello, un file denominato en-chunker.bin. Questo è un modello predefinito che è addestrato a dividere le frasi nel testo grezzo dato.

Il opennlp.tools.chunker Il pacchetto contiene le classi e le interfacce che vengono utilizzate per trovare annotazioni sintattiche non ricorsive come blocchi di frasi nominali.

Puoi dividere una frase usando il metodo chunk() del ChunkerMEclasse. Questo metodo accetta i token di una frase e tag POS come parametri. Pertanto, prima di iniziare il processo di chunking, prima di tutto è necessario tokenizzare la frase e generare i tag POS delle parti di essa.

Per suddividere una frase utilizzando la libreria OpenNLP, è necessario:

  • Tokenizza la frase.

  • Genera tag POS per questo.

  • Carica il file en-chunker.bin modello utilizzando il ChunkerModel classe

  • Istanziare il file ChunkerME classe.

  • Suddividi le frasi usando il chunk() metodo di questa classe.

Di seguito sono riportati i passaggi da seguire per scrivere un programma in blocchi di frasi dal testo grezzo specificato.

Passaggio 1: tokenizzazione della frase

Tokenizza le frasi usando il tokenize() metodo del whitespaceTokenizer class, come mostrato nel seguente blocco di codice.

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

Passaggio 2: generazione dei tag POS

Genera i tag POS della frase utilizzando il tag() metodo del POSTaggerME class, come mostrato nel seguente blocco di codice.

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

Passaggio 3: caricamento del modello

Il modello per suddividere una frase è rappresentato dalla classe denominata ChunkerModel, che appartiene al pacchetto opennlp.tools.chunker.

Per caricare un modello di rilevamento della frase:

  • Creare un InputStream oggetto del modello (creare un'istanza di FileInputStream e passare il percorso del modello in formato String al suo costruttore).

  • Istanziare il file ChunkerModel class e passare il InputStream (oggetto) del modello come parametro del suo costruttore, come mostrato nel seguente blocco di codice:

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

Passaggio 4: creazione di un'istanza della classe chunkerME

Il chunkerME classe del pacchetto opennlp.tools.chunkercontiene metodi per suddividere le frasi. Questo è un chunker basato sulla massima entropia.

Crea un'istanza di questa classe e passa l'oggetto modello creato nel passaggio precedente.

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

Passaggio 5: suddivisione della frase

Il chunk() metodo del ChunkerMEclass è usata per suddividere le frasi nel testo grezzo che gli è stato passato. Questo metodo accetta due array di stringhe che rappresentano token e tag, come parametri.

Richiamare questo metodo passando come parametri l'array di token e l'array di tag creati nei passaggi precedenti.

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

Example

Di seguito è riportato il programma per suddividere le frasi nel testo grezzo fornito. Salva questo programma in un file con il 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);         
   }    
}

Compilare ed eseguire il file Java salvato dal prompt dei comandi utilizzando il seguente comando:

javac ChunkerExample.java 
java ChunkerExample

All'esecuzione, il programma precedente legge la stringa data e suddivide le frasi al suo interno e le visualizza come mostrato di seguito.

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

Rilevamento delle posizioni dei token

Possiamo anche rilevare le posizioni o gli intervalli dei blocchi utilizzando chunkAsSpans() metodo del ChunkerMEclasse. Questo metodo restituisce una matrice di oggetti del tipo Span. La classe denominata Span of theopennlp.tools.util pacchetto viene utilizzato per memorizzare il file start e end numero intero di insiemi.

È possibile memorizzare gli intervalli restituiti da chunkAsSpans() nell'array Span e stamparli, come mostrato nel seguente blocco di codice.

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

Example

Di seguito è riportato il programma che rileva le frasi nel testo grezzo fornito. Salva questo programma in un file con il 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());  
   }    
}

Compilare ed eseguire il file Java salvato dal prompt dei comandi utilizzando i seguenti comandi:

javac ChunkerSpansEample.java 
java ChunkerSpansEample

All'esecuzione, il programma precedente legge la stringa data e gli intervalli dei blocchi in essa contenuti e visualizza il seguente output:

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

Chunker Probability Detection

Il probs() metodo del ChunkerME class restituisce le probabilità dell'ultima sequenza decodificata.

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

Di seguito è riportato il programma per stampare le probabilità dell'ultima sequenza decodificata dal chunker. Salva questo programma in un file con il 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]);       
   }    
}

Compilare ed eseguire il file Java salvato dal prompt dei comandi utilizzando i seguenti comandi:

javac ChunkerProbsExample.java 
java ChunkerProbsExample

Durante l'esecuzione, il programma precedente legge la stringa data, la suddivide in blocchi e stampa le probabilità dell'ultima sequenza decodificata.

0.9592746040797778 
0.6883933131241501 
0.8830563473996004 
0.8951150529746051

OpenNLP fornisce un'interfaccia a riga di comando (CLI) per eseguire diverse operazioni tramite la riga di comando. In questo capitolo, prenderemo alcuni esempi per mostrare come possiamo usare l'interfaccia a riga di comando di OpenNLP.

Tokenizzazione

input.txt

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

Sintassi

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

comando

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

produzione

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

Rilevamento di frasi

input.txt

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

Sintassi

> 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

Produzione

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

Riconoscimento di entità nominate

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

Sintassi

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

Comando

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

Produzione

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

Parti del riconoscimento vocale

Input.txt

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

Sintassi

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

Comando

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

Produzione

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