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