OpenNLP - Guide rapide

La PNL est un ensemble d'outils utilisés pour obtenir des informations significatives et utiles à partir de sources en langage naturel telles que des pages Web et des documents texte.

Qu'est-ce que Open NLP?

Apache OpenNLPest une bibliothèque Java open-source utilisée pour traiter du texte en langage naturel. Vous pouvez créer un service de traitement de texte efficace à l'aide de cette bibliothèque.

OpenNLP fournit des services tels que la tokenisation, la segmentation de phrases, le marquage d'une partie du discours, l'extraction d'entités nommées, la segmentation, l'analyse et la résolution de co-référence, etc.

Caractéristiques d'OpenNLP

Voici les caractéristiques notables d'OpenNLP -

• Named Entity Recognition (NER) - Open NLP prend en charge NER, à l'aide duquel vous pouvez extraire les noms de lieux, de personnes et de choses même lors du traitement des requêtes.

• Summarize - Utilisation du summarize fonctionnalité, vous pouvez résumer les paragraphes, articles, documents ou leur collection en PNL.

• Searching - Dans OpenNLP, une chaîne de recherche donnée ou ses synonymes peuvent être identifiés dans un texte donné, même si le mot donné est altéré ou mal orthographié.

• Tagging (POS) - Le marquage en PNL est utilisé pour diviser le texte en divers éléments grammaticaux pour une analyse plus approfondie.

• Translation - En PNL, la traduction aide à traduire une langue dans une autre.

• Information grouping - Cette option de NLP regroupe les informations textuelles dans le contenu du document, tout comme Parties de discours.

• Natural Language Generation - Il est utilisé pour générer des informations à partir d'une base de données et automatiser les rapports d'informations tels que les analyses météorologiques ou les rapports médicaux.

• Feedback Analysis - Comme son nom l'indique, différents types de retours de personnes sont collectés, concernant les produits, par la PNL pour analyser dans quelle mesure le produit réussit à gagner leur cœur.

• Speech recognition - Bien qu'il soit difficile d'analyser la parole humaine, la PNL a des fonctionnalités intégrées pour cette exigence.

Ouvrir l'API NLP

La bibliothèque Apache OpenNLP fournit des classes et des interfaces pour effectuer diverses tâches de traitement du langage naturel telles que la détection de phrases, la tokenisation, la recherche d'un nom, le balisage des parties du discours, la segmentation d'une phrase, l'analyse, la résolution de co-référence et la catégorisation de documents.

En plus de ces tâches, nous pouvons également former et évaluer nos propres modèles pour n'importe laquelle de ces tâches.

CLI OpenNLP

En plus de la bibliothèque, OpenNLP fournit également une interface de ligne de commande (CLI), où nous pouvons former et évaluer des modèles. Nous aborderons ce sujet en détail dans le dernier chapitre de ce tutoriel.

Modèles PNL ouverts

Pour effectuer diverses tâches NLP, OpenNLP fournit un ensemble de modèles prédéfinis. Cet ensemble comprend des modèles pour différentes langues.

Téléchargement des modèles

Vous pouvez suivre les étapes ci-dessous pour télécharger les modèles prédéfinis fournis par OpenNLP.

Step 1 - Ouvrez la page d'index des modèles OpenNLP en cliquant sur le lien suivant - http://opennlp.sourceforge.net/models-1.5/.

Step 2- En visitant le lien donné, vous pourrez voir une liste de composants de différentes langues et les liens pour les télécharger. Ici, vous pouvez obtenir la liste de tous les modèles prédéfinis fournis par OpenNLP.

Téléchargez tous ces modèles dans le dossier C:/OpenNLP_models/>, en cliquant sur leurs liens respectifs. Tous ces modèles dépendent de la langue et lors de leur utilisation, vous devez vous assurer que la langue du modèle correspond à la langue du texte d'entrée.

Histoire d'OpenNLP

• En 2010, OpenNLP est entré dans l'incubation Apache.

• En 2011, Apache OpenNLP 1.5.2 Incubating a été publié, et la même année, il a obtenu son diplôme en tant que projet Apache de haut niveau.

• En 2015, OpenNLP était la version 1.6.0.

Dans ce chapitre, nous verrons comment vous pouvez configurer l'environnement OpenNLP dans votre système. Commençons par le processus d'installation.

Installation d'OpenNLP

Voici les étapes pour télécharger Apache OpenNLP library dans votre système.

Step 1 - Ouvrez la page d'accueil de Apache OpenNLP en cliquant sur le lien suivant - https://opennlp.apache.org/.

Step 2 - Maintenant, cliquez sur le Downloadslien. En cliquant, vous serez dirigé vers une page où vous pourrez trouver divers miroirs qui vous redirigeront vers le répertoire Apache Software Foundation Distribution.

Step 3- Dans cette page, vous pouvez trouver des liens pour télécharger diverses distributions Apache. Parcourez-les et trouvez la distribution OpenNLP et cliquez dessus.

Step 4 - En cliquant, vous serez redirigé vers le répertoire où vous pouvez voir l'index de la distribution OpenNLP, comme indiqué ci-dessous.

Cliquez sur la dernière version parmi les distributions disponibles.

Step 5- Chaque distribution fournit des fichiers source et binaire de la bibliothèque OpenNLP dans différents formats. Téléchargez les fichiers source et binaire,apache-opennlp-1.6.0-bin.zip et apache-opennlp1.6.0-src.zip (Pour les fenêtres).

Définition du chemin de classe

Après avoir téléchargé la bibliothèque OpenNLP, vous devez définir son chemin vers le binannuaire. Supposons que vous ayez téléchargé la bibliothèque OpenNLP sur le lecteur E de votre système.

Maintenant, suivez les étapes ci-dessous -

Step 1 - Cliquez avec le bouton droit sur «Poste de travail» et sélectionnez «Propriétés».

Step 2 - Cliquez sur le bouton «Variables d'environnement» sous l'onglet «Avancé».

Step 3 - Sélectionnez le path variable et cliquez sur Edit bouton, comme indiqué dans la capture d'écran suivante.

Step 4 - Dans la fenêtre Modifier la variable d'environnement, cliquez sur le New et ajoutez le chemin du répertoire OpenNLP E:\apache-opennlp-1.6.0\bin et cliquez sur le OK bouton, comme indiqué dans la capture d'écran suivante.

Installation d'Eclipse

Vous pouvez définir l'environnement Eclipse pour la bibliothèque OpenNLP, soit en définissant le Build path aux fichiers JAR ou en utilisant pom.xml.

Définition du chemin de construction des fichiers JAR

Suivez les étapes ci-dessous pour installer OpenNLP dans Eclipse -

Step 1 - Assurez-vous que l'environnement Eclipse est installé sur votre système.

Step 2- Ouvrez Eclipse. Cliquez sur Fichier → Nouveau → Ouvrir un nouveau projet, comme indiqué ci-dessous.

Step 3 - Vous obtiendrez le New Projectsorcier. Dans cet assistant, sélectionnez le projet Java et continuez en cliquant sur leNext bouton.

Step 4 - Ensuite, vous obtiendrez le New Java Project wizard. Ici, vous devez créer un nouveau projet et cliquer sur le boutonNext bouton, comme illustré ci-dessous.

Step 5 - Après avoir créé un nouveau projet, faites un clic droit dessus, sélectionnez Build Path et cliquez Configure Build Path.

Step 6 - Ensuite, vous obtiendrez le Java Build Pathsorcier. Ici, cliquez sur leAdd External JARs bouton, comme illustré ci-dessous.

Step 7 - Sélectionnez les fichiers jar opennlp-tools-1.6.0.jar et opennlp-uima-1.6.0.jar située dans le lib dossier de apache-opennlp-1.6.0 folder.

En cliquant sur le Open dans l'écran ci-dessus, les fichiers sélectionnés seront ajoutés à votre bibliothèque.

En cliquant OK, vous ajouterez avec succès les fichiers JAR requis au projet actuel et vous pourrez vérifier ces bibliothèques ajoutées en développant les bibliothèques référencées, comme indiqué ci-dessous.

Utilisation de pom.xml

Convertissez le projet en projet Maven et ajoutez le code suivant à son 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>

Dans ce chapitre, nous discuterons des classes et des méthodes que nous utiliserons dans les chapitres suivants de ce didacticiel.

Détection des phrases

PhraseModel classe

Cette classe représente le modèle prédéfini utilisé pour détecter les phrases dans le texte brut donné. Cette classe appartient au packageopennlp.tools.sentdetect.

Le constructeur de cette classe accepte un InputStream objet du fichier modèle du détecteur de phrases (en-sent.bin).

PhraseDetectorME classe

Cette classe appartient au package opennlp.tools.sentdetectet il contient des méthodes pour diviser le texte brut en phrases. Cette classe utilise un modèle d'entropie maximale pour évaluer les caractères de fin de phrase dans une chaîne afin de déterminer s'ils signifient la fin d'une phrase.

Voici les méthodes importantes de cette classe.

S.Non	Méthodes et description
1	sentDetect() Cette méthode est utilisée pour détecter les phrases dans le texte brut qui lui est passé. Il accepte une variable String comme paramètre et retourne un tableau String qui contient les phrases du texte brut donné.
2	sentPosDetect() Cette méthode est utilisée pour détecter les positions des phrases dans le texte donné. Cette méthode accepte une variable chaîne, représentant la phrase et retourne un tableau d'objets du typeSpan. La classe nommée Span du opennlp.tools.util package est utilisé pour stocker les entiers de début et de fin des ensembles.
3	getSentenceProbabilities() Cette méthode renvoie les probabilités associées aux appels les plus récents à sentDetect() méthode.

Tokenisation

Classe TokenizerModel

Cette classe représente le modèle prédéfini qui est utilisé pour tokeniser la phrase donnée. Cette classe appartient au packageopennlp.tools.tokenizer.

Le constructeur de cette classe accepte un InputStream objet du fichier de modèle de tokenizer (entoken.bin).

Des classes

Pour effectuer la tokenisation, la bibliothèque OpenNLP fournit trois classes principales. Les trois classes implémentent l'interface appeléeTokenizer.

S.Non	Classes et description
1	SimpleTokenizer Cette classe symbolise le texte brut donné en utilisant des classes de caractères.
2	WhitespaceTokenizer Cette classe utilise des espaces pour tokeniser le texte donné.
3	TokenizerME Cette classe convertit le texte brut en jetons séparés. Il utilise l'Entropie maximale pour prendre ses décisions.

Ces classes contiennent les méthodes suivantes.

S.Non	Méthodes et description
1	tokenize() Cette méthode est utilisée pour tokeniser le texte brut. Cette méthode accepte une variable String comme paramètre et renvoie un tableau de Strings (jetons).
2	sentPosDetect() Cette méthode est utilisée pour obtenir les positions ou les étendues des jetons. Il accepte la phrase (ou) le texte brut sous la forme de la chaîne et renvoie un tableau d'objets du typeSpan.

En plus des deux méthodes ci-dessus, le TokenizerME la classe a le getTokenProbabilities() méthode.

S.Non	Méthodes et description
1	getTokenProbabilities() Cette méthode est utilisée pour obtenir les probabilités associées aux appels les plus récents au tokenizePos() méthode.

NomEntitéReconnaissance

Classe TokenNameFinderModel

Cette classe représente le modèle prédéfini utilisé pour rechercher les entités nommées dans la phrase donnée. Cette classe appartient au packageopennlp.tools.namefind.

Le constructeur de cette classe accepte un InputStream objet du fichier de modèle de recherche de noms (enner-person.bin).

Classe NameFinderME

La classe appartient au package opennlp.tools.namefindet il contient des méthodes pour effectuer les tâches NER. Cette classe utilise un modèle d'entropie maximale pour trouver les entités nommées dans le texte brut donné.

S.Non	Méthodes et description
1	find() Cette méthode est utilisée pour détecter les noms dans le texte brut. Il accepte une variable String représentant le texte brut en tant que paramètre et renvoie un tableau d'objets de type Span.
2	probs() Cette méthode permet d'obtenir les probabilités de la dernière séquence décodée.

Trouver les parties du discours

Classe POSModel

Cette classe représente le modèle prédéfini qui est utilisé pour baliser les parties du discours de la phrase donnée. Cette classe appartient au packageopennlp.tools.postag.

Le constructeur de cette classe accepte un InputStream objet du fichier de modèle pos-tagger (enpos-maxent.bin).

Classe POSTaggerME

Cette classe appartient au package opennlp.tools.postaget il est utilisé pour prédire les parties du discours du texte brut donné. Il utilise l'Entropie maximale pour prendre ses décisions.

S.Non	Méthodes et description
1	tag() Cette méthode est utilisée pour attribuer la phrase des balises POS de jetons. Cette méthode accepte un tableau de jetons (String) en tant que paramètre et renvoie une balise (tableau).
2	getSentenceProbabilities() Cette méthode est utilisée pour obtenir les probabilités pour chaque balise de la phrase récemment balisée.

Analyse de la phrase

Classe ParserModel

Cette classe représente le modèle prédéfini utilisé pour analyser la phrase donnée. Cette classe appartient au packageopennlp.tools.parser.

Le constructeur de cette classe accepte un InputStream objet du fichier modèle de l'analyseur (en-parserchunking.bin).

Classe Parser Factory

Cette classe appartient au package opennlp.tools.parser et il est utilisé pour créer des analyseurs.

S.Non	Méthodes et description
1	create() Il s'agit d'une méthode statique utilisée pour créer un objet analyseur. Cette méthode accepte l'objet Filestream du fichier modèle de l'analyseur.

Classe ParserTool

Cette classe appartient à la opennlp.tools.cmdline.parser package et, il est utilisé pour analyser le contenu.

S.Non	Méthodes et description
1	parseLine() Cette méthode de la ParserToolLa classe est utilisée pour analyser le texte brut dans OpenNLP. Cette méthode accepte - Une variable String représentant le texte à analyser. Un objet analyseur. Un entier représentant le nombre d'analyses à effectuer.

Regrouper

Classe ChunkerModel

Cette classe représente le modèle prédéfini qui est utilisé pour diviser une phrase en petits morceaux. Cette classe appartient au packageopennlp.tools.chunker.

Le constructeur de cette classe accepte un InputStream objet de la chunker fichier modèle (enchunker.bin).

Classe ChunkerME

Cette classe appartient au package nommé opennlp.tools.chunker et il est utilisé pour diviser la phrase donnée en morceaux plus petits.

S.Non	Méthodes et description
1	chunk() Cette méthode est utilisée pour diviser la phrase donnée en morceaux plus petits. Il accepte les jetons d'une phrase etPles arts OF Sbalises peech comme paramètres.
2	probs() Cette méthode renvoie les probabilités de la dernière séquence décodée.

Lors du traitement d'un langage naturel, décider du début et de la fin des phrases est l'un des problèmes à résoudre. Ce processus est connu sous le nom deSentence Bbord Disambiguation (SBD) ou simplement rupture de phrase.

Les techniques que nous utilisons pour détecter les phrases dans le texte donné dépendent de la langue du texte.

Détection de phrases à l'aide de Java

Nous pouvons détecter les phrases dans le texte donné en Java en utilisant des expressions régulières et un ensemble de règles simples.

Par exemple, supposons qu'un point, un point d'interrogation ou un point d'exclamation termine une phrase dans le texte donné, puis nous pouvons diviser la phrase en utilisant le split() méthode de la Stringclasse. Ici, nous devons passer une expression régulière au format String.

Voici le programme qui détermine les phrases dans un texte donné à l'aide d'expressions régulières Java (split method). Enregistrez ce programme dans un fichier avec le nomSentenceDetection_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);      
   } 
}

Compilez et exécutez le fichier java enregistré à partir de l'invite de commande à l'aide des commandes suivantes.

javac SentenceDetection_RE.java 
java SentenceDetection_RE

Lors de l'exécution, le programme ci-dessus crée un document PDF affichant le message suivant.

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

Détection de phrases à l'aide d'OpenNLP

Pour détecter les phrases, OpenNLP utilise un modèle prédéfini, un fichier nommé en-sent.bin. Ce modèle prédéfini est formé pour détecter des phrases dans un texte brut donné.

le opennlp.tools.sentdetect package contient les classes et interfaces utilisées pour effectuer la tâche de détection de phrase.

Pour détecter une phrase à l'aide de la bibliothèque OpenNLP, vous devez -

• Chargez le en-sent.bin modèle utilisant le SentenceModel classe

• Instancier le SentenceDetectorME classe.

• Détectez les phrases à l'aide du sentDetect() méthode de cette classe.

Voici les étapes à suivre pour écrire un programme qui détecte les phrases du texte brut donné.

Étape 1: chargement du modèle

Le modèle de détection de phrase est représenté par la classe nommée SentenceModel, qui appartient au package opennlp.tools.sentdetect.

Pour charger un modèle de détection de phrase -

• Créé un InputStream objet du modèle (instanciez le FileInputStream et passez le chemin du modèle au format String à son constructeur).

• Instancier le SentenceModel classe et passer le InputStream (objet) du modèle en tant que paramètre de son constructeur comme indiqué dans le bloc de code suivant -

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

Étape 2: instanciation de la classe SentenceDetectorME

le SentenceDetectorME classe du package opennlp.tools.sentdetectcontient des méthodes pour diviser le texte brut en phrases. Cette classe utilise le modèle d'entropie maximale pour évaluer les caractères de fin de phrase dans une chaîne afin de déterminer s'ils signifient la fin d'une phrase.

Instanciez cette classe et transmettez l'objet modèle créé à l'étape précédente, comme indiqué ci-dessous.

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

Étape 3: Détecter la phrase

le sentDetect() méthode de la SentenceDetectorMEclass est utilisé pour détecter les phrases dans le texte brut qui lui est passé. Cette méthode accepte une variable String comme paramètre.

Appelez cette méthode en transmettant le format String de la phrase à cette méthode.

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

Example

Voici le programme qui détecte les phrases dans un texte brut donné. Enregistrez ce programme dans un fichier nomméSentenceDetectionME.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);  
   } 
}

Compilez et exécutez le fichier Java enregistré à partir de l'invite de commande à l'aide des commandes suivantes -

javac SentenceDetectorME.java 
java SentenceDetectorME

Lors de l'exécution, le programme ci-dessus lit la chaîne donnée et détecte les phrases qu'elle contient et affiche la sortie suivante.

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

Détecter les positions des phrases

On peut également détecter les positions des phrases en utilisant la méthode sentPosDetect () du SentenceDetectorME class.

Voici les étapes à suivre pour écrire un programme qui détecte les positions des phrases à partir du texte brut donné.

Étape 1: chargement du modèle

Le modèle de détection de phrase est représenté par la classe nommée SentenceModel, qui appartient au package opennlp.tools.sentdetect.

Pour charger un modèle de détection de phrase -

• Créé un InputStream objet du modèle (instanciez le FileInputStream et passez le chemin du modèle au format String à son constructeur).

• Instancier le SentenceModel classe et passer le InputStream (objet) du modèle en tant que paramètre de son constructeur, comme indiqué dans le bloc de code suivant.

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

Étape 2: instanciation de la classe SentenceDetectorME

le SentenceDetectorME classe du package opennlp.tools.sentdetectcontient des méthodes pour diviser le texte brut en phrases. Cette classe utilise le modèle d'entropie maximale pour évaluer les caractères de fin de phrase dans une chaîne afin de déterminer s'ils signifient la fin d'une phrase.

Instanciez cette classe et transmettez l'objet modèle créé à l'étape précédente.

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

Étape 3: Détecter la position de la phrase

le sentPosDetect() méthode de la SentenceDetectorMEclass est utilisé pour détecter les positions des phrases dans le texte brut qui lui est passé. Cette méthode accepte une variable String comme paramètre.

Appelez cette méthode en transmettant le format String de la phrase en tant que paramètre à cette méthode.

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

Étape 4: Impression des travées des phrases

le sentPosDetect() méthode de la SentenceDetectorME class renvoie un tableau d'objets du type Span. La classe nommée Span of theopennlp.tools.util package est utilisé pour stocker les entiers de début et de fin des ensembles.

Vous pouvez stocker les portées renvoyées par le sentPosDetect() dans le tableau Span et imprimez-les, comme indiqué dans le bloc de code suivant.

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

Example

Voici le programme qui détecte les phrases dans le texte brut donné. Enregistrez ce programme dans un fichier nomméSentenceDetectionME.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);  
   } 
}

Compilez et exécutez le fichier Java enregistré à partir de l'invite de commande à l'aide des commandes suivantes -

javac SentencePosDetection.java 
java SentencePosDetection

Lors de l'exécution, le programme ci-dessus lit la chaîne donnée et détecte les phrases qu'elle contient et affiche la sortie suivante.

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

Phrases avec leurs positions

le substring() méthode de la classe String accepte le begin et le end offsetset renvoie la chaîne respective. Nous pouvons utiliser cette méthode pour imprimer les phrases et leurs étendues (positions) ensemble, comme indiqué dans le bloc de code suivant.

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

Voici le programme pour détecter les phrases à partir du texte brut donné et les afficher avec leurs positions. Enregistrez ce programme dans un fichier avec un nomSentencesAndPosDetection.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);  
   } 
}

Compilez et exécutez le fichier Java enregistré à partir de l'invite de commande à l'aide des commandes suivantes -

javac SentencesAndPosDetection.java 
java SentencesAndPosDetection

Lors de l'exécution, le programme ci-dessus lit la chaîne donnée et détecte les phrases avec leurs positions et affiche la sortie suivante.

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

Détection de probabilité de phrase

le getSentenceProbabilities() méthode de la SentenceDetectorME class renvoie les probabilités associées aux appels les plus récents à la méthode sentDetect ().

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

Voici le programme pour imprimer les probabilités associées aux appels à la méthode sentDetect (). Enregistrez ce programme dans un fichier avec le nomSentenceDetectionMEProbs.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]); 
   } 
}

Compilez et exécutez le fichier Java enregistré à partir de l'invite de commande à l'aide des commandes suivantes -

javac SentenceDetectionMEProbs.java 
java SentenceDetectionMEProbs

Lors de l'exécution, le programme ci-dessus lit la chaîne donnée, détecte les phrases et les imprime. En outre, il renvoie également les probabilités associées aux appels les plus récents à la méthode sentDetect (), comme indiqué ci-dessous.

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

Le processus de découpage de la phrase donnée en parties plus petites (jetons) est appelé tokenization. En général, le texte brut donné est tokenisé en fonction d'un ensemble de délimiteurs (principalement des espaces).

La tokenisation est utilisée dans des tâches telles que la vérification orthographique, le traitement des recherches, l'identification de parties de discours, la détection de phrases, la classification de documents de documents, etc.

Tokenizing avec OpenNLP

le opennlp.tools.tokenize package contient les classes et les interfaces utilisées pour effectuer la tokenisation.

Pour tokeniser les phrases données en fragments plus simples, la bibliothèque OpenNLP fournit trois classes différentes -

• SimpleTokenizer - Cette classe tokenise le texte brut donné en utilisant des classes de caractères.

• WhitespaceTokenizer - Cette classe utilise des espaces pour tokeniser le texte donné.

• TokenizerME- Cette classe convertit le texte brut en jetons séparés. Il utilise l'Entropie maximale pour prendre ses décisions.

SimpleTokenizer

Pour tokeniser une phrase en utilisant le SimpleTokenizer classe, vous devez -

• Créez un objet de la classe respective.

• Tokenize la phrase en utilisant le tokenize() méthode.

• Imprimez les jetons.

Voici les étapes à suivre pour écrire un programme qui tokenise le texte brut donné.

Step 1 - Instanciation de la classe respective

Dans les deux classes, aucun constructeur n'est disponible pour les instancier. Par conséquent, nous devons créer des objets de ces classes en utilisant la variable statiqueINSTANCE.

SimpleTokenizer tokenizer = SimpleTokenizer.INSTANCE;

Step 2 - Tokenize les phrases

Ces deux classes contiennent une méthode appelée tokenize(). Cette méthode accepte un texte brut au format String. Lors de l'appel, il tokenise la chaîne donnée et renvoie un tableau de chaînes (jetons).

Tokenize la phrase en utilisant le tokenizer() méthode comme indiqué ci-dessous.

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

Step 3 - Imprimez les jetons

Après avoir marqué la phrase, vous pouvez imprimer les jetons en utilisant for loop, comme indiqué ci-dessous.

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

Example

Voici le programme qui tokenise la phrase donnée en utilisant la classe SimpleTokenizer. Enregistrez ce programme dans un fichier avec le nomSimpleTokenizerExample.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);  
      }       
   }  
}

Compilez et exécutez le fichier Java enregistré à partir de l'invite de commande à l'aide des commandes suivantes -

javac SimpleTokenizerExample.java 
java SimpleTokenizerExample

Lors de l'exécution, le programme ci-dessus lit la chaîne donnée (texte brut), la tokenise et affiche la sortie suivante -

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

Espace blancTokenizer

Pour tokeniser une phrase en utilisant le WhitespaceTokenizer classe, vous devez -

• Créez un objet de la classe respective.

• Tokenize la phrase en utilisant le tokenize() méthode.

• Imprimez les jetons.

Voici les étapes à suivre pour écrire un programme qui tokenise le texte brut donné.

Step 1 - Instanciation de la classe respective

Dans les deux classes, aucun constructeur n'est disponible pour les instancier. Par conséquent, nous devons créer des objets de ces classes en utilisant la variable statiqueINSTANCE.

WhitespaceTokenizer tokenizer = WhitespaceTokenizer.INSTANCE;

Step 2 - Tokenize les phrases

Ces deux classes contiennent une méthode appelée tokenize(). Cette méthode accepte un texte brut au format String. Lors de l'appel, il tokenise la chaîne donnée et renvoie un tableau de chaînes (jetons).

Tokenize la phrase en utilisant le tokenizer() méthode comme indiqué ci-dessous.

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

Step 3 - Imprimez les jetons

Après avoir marqué la phrase, vous pouvez imprimer les jetons en utilisant for loop, comme indiqué ci-dessous.

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

Example

Voici le programme qui tokenise la phrase donnée en utilisant le WhitespaceTokenizerclasse. Enregistrez ce programme dans un fichier avec le nomWhitespaceTokenizerExample.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);        
   } 
}

Compilez et exécutez le fichier Java enregistré à partir de l'invite de commande à l'aide des commandes suivantes -

javac WhitespaceTokenizerExample.java 
java WhitespaceTokenizerExample

Lors de l'exécution, le programme ci-dessus lit la chaîne donnée (texte brut), la tokenise et affiche la sortie suivante.

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

Classe TokenizerME

OpenNLP utilise également un modèle prédéfini, un fichier nommé de-token.bin, pour tokeniser les phrases. Il est formé pour tokeniser les phrases dans un texte brut donné.

le TokenizerME classe de la opennlp.tools.tokenizerpackage est utilisé pour charger ce modèle et tokeniser le texte brut donné à l'aide de la bibliothèque OpenNLP. Pour ce faire, vous devez -

• Chargez le en-token.bin modèle utilisant le TokenizerModel classe.

• Instancier le TokenizerME classe.

• Tokenize les phrases en utilisant le tokenize() méthode de cette classe.

Voici les étapes à suivre pour écrire un programme qui tokenise les phrases du texte brut donné en utilisant le TokenizerME classe.

Step 1 - Chargement du modèle

Le modèle de tokenisation est représenté par la classe nommée TokenizerModel, qui appartient au package opennlp.tools.tokenize.

Pour charger un modèle de tokenizer -

• Créé un InputStream objet du modèle (instanciez le FileInputStream et passez le chemin du modèle au format String à son constructeur).

• Instancier le TokenizerModel classe et passer le InputStream (objet) du modèle en tant que paramètre de son constructeur, comme indiqué dans le bloc de code suivant.

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

Step 2 - Instanciation de la classe TokenizerME

le TokenizerME classe du package opennlp.tools.tokenizecontient des méthodes pour découper le texte brut en parties plus petites (jetons). Il utilise l'Entropie maximale pour prendre ses décisions.

Instanciez cette classe et transmettez l'objet modèle créé à l'étape précédente comme indiqué ci-dessous.

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

Step 3 - Tokeniser la phrase

le tokenize() méthode de la TokenizerMEclass est utilisé pour tokeniser le texte brut qui lui est passé. Cette méthode accepte une variable String comme paramètre et renvoie un tableau de Strings (jetons).

Appelez cette méthode en transmettant le format String de la phrase à cette méthode, comme suit.

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

Example

Voici le programme qui tokenise le texte brut donné. Enregistrez ce programme dans un fichier avec le nomTokenizerMEExample.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); 
   } 
}

Compilez et exécutez le fichier Java enregistré à partir de l'invite de commande à l'aide des commandes suivantes -

javac TokenizerMEExample.java 
java TokenizerMEExample

Lors de l'exécution, le programme ci-dessus lit la chaîne donnée et détecte les phrases qu'elle contient et affiche la sortie suivante -

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

Récupération des positions des jetons

Nous pouvons également obtenir les positions ou spans des jetons utilisant le tokenizePos()méthode. C'est la méthode de l'interface Tokenizer du packageopennlp.tools.tokenize. Puisque toutes les (trois) classes Tokenizer implémentent cette interface, vous pouvez trouver cette méthode dans chacune d'elles.

Cette méthode accepte la phrase ou le texte brut sous la forme d'une chaîne et renvoie un tableau d'objets du type Span.

Vous pouvez obtenir les positions des jetons en utilisant le tokenizePos() méthode, comme suit -

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

Impression des positions (travées)

La classe nommée Span du opennlp.tools.util package est utilisé pour stocker les entiers de début et de fin des ensembles.

Vous pouvez stocker les portées renvoyées par le tokenizePos() dans le tableau Span et imprimez-les, comme indiqué dans le bloc de code suivant.

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

Impression des jetons et de leurs positions ensemble

le substring() méthode de la classe String accepte le begin et le enddécale et renvoie la chaîne respective. Nous pouvons utiliser cette méthode pour imprimer les jetons et leurs étendues (positions) ensemble, comme indiqué dans le bloc de code suivant.

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

Example(SimpleTokenizer)

Voici le programme qui récupère les étendues de jetons du texte brut en utilisant le SimpleTokenizerclasse. Il imprime également les jetons avec leurs positions. Enregistrez ce programme dans un fichier nomméSimpleTokenizerSpans.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()));          
   } 
}

Compilez et exécutez le fichier Java enregistré à partir de l'invite de commande à l'aide des commandes suivantes -

javac SimpleTokenizerSpans.java 
java SimpleTokenizerSpans

Lors de l'exécution, le programme ci-dessus lit la chaîne donnée (texte brut), la tokenise et affiche la sortie suivante -

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

Voici le programme qui récupère les étendues de jetons du texte brut en utilisant le WhitespaceTokenizerclasse. Il imprime également les jetons avec leurs positions. Enregistrez ce programme dans un fichier avec le nomWhitespaceTokenizerSpans.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()));        
   } 
}

Compilez et exécutez le fichier java enregistré à partir de l'invite de commande à l'aide des commandes suivantes

javac WhitespaceTokenizerSpans.java 
java WhitespaceTokenizerSpans

Lors de l'exécution, le programme ci-dessus lit la chaîne donnée (texte brut), la tokenise et affiche la sortie suivante.

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

Voici le programme qui récupère les étendues de jetons du texte brut en utilisant le TokenizerMEclasse. Il imprime également les jetons avec leurs positions. Enregistrez ce programme dans un fichier avec le nomTokenizerMESpans.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()));      
   } 
}

Compilez et exécutez le fichier Java enregistré à partir de l'invite de commande à l'aide des commandes suivantes -

javac TokenizerMESpans.java 
java TokenizerMESpans

Lors de l'exécution, le programme ci-dessus lit la chaîne donnée (texte brut), la tokenise et affiche la sortie suivante -

[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é du tokenizer

La méthode getTokenProbabilities () de la classe TokenizerME est utilisée pour obtenir les probabilités associées aux appels les plus récents à la méthode tokenizePos ().

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

Voici le programme pour imprimer les probabilités associées aux appels à la méthode tokenizePos (). Enregistrez ce programme dans un fichier avec le nomTokenizerMEProbs.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]);          
   } 
}

Compilez et exécutez le fichier Java enregistré à partir de l'invite de commande à l'aide des commandes suivantes -

javac TokenizerMEProbs.java 
java TokenizerMEProbs

Lors de l'exécution, le programme ci-dessus lit la chaîne donnée et tokenise les phrases et les imprime. De plus, il renvoie également les probabilités associées aux appels les plus récents à la méthode 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

Le processus de recherche de noms, de personnes, de lieux et d'autres entités à partir d'un texte donné est appelé Named Entité Rreconnaissance (NER). Dans ce chapitre, nous discuterons de la manière d'exécuter NER via le programme Java en utilisant la bibliothèque OpenNLP.

Reconnaissance d'entités nommées à l'aide de NLP ouvert

Pour effectuer diverses tâches NER, OpenNLP utilise différents modèles prédéfinis, à savoir, en-nerdate.bn, en-ner-location.bin, en-ner-organization.bin, en-ner-person.bin et en-ner-time. poubelle. Tous ces fichiers sont des modèles prédéfinis qui sont formés pour détecter les entités respectives dans un texte brut donné.

le opennlp.tools.namefindpackage contient les classes et les interfaces utilisées pour exécuter la tâche NER. Pour effectuer une tâche NER à l'aide de la bibliothèque OpenNLP, vous devez -

• Chargez le modèle respectif à l'aide du TokenNameFinderModel classe.

• Instancier le NameFinder classe.

• Trouvez les noms et imprimez-les.

Voici les étapes à suivre pour écrire un programme qui détecte les entités de nom à partir d'un texte brut donné.

Étape 1: chargement du modèle

Le modèle de détection de phrase est représenté par la classe nommée TokenNameFinderModel, qui appartient au package opennlp.tools.namefind.

Pour charger un modèle NER -

• Créé un InputStream objet du modèle (instanciez le FileInputStream et passez le chemin du modèle NER approprié au format String à son constructeur).

• Instancier le TokenNameFinderModel classe et passer le InputStream (objet) du modèle en tant que paramètre de son constructeur, comme indiqué dans le bloc de code suivant.

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

Étape 2: instanciation de la classe NameFinderME

le NameFinderME classe du package opennlp.tools.namefindcontient des méthodes pour effectuer les tâches NER. Cette classe utilise le modèle d'entropie maximale pour rechercher les entités nommées dans le texte brut donné.

Instanciez cette classe et transmettez l'objet modèle créé à l'étape précédente comme indiqué ci-dessous -

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

Étape 3: Trouver les noms dans la phrase

le find() méthode de la NameFinderMEclass est utilisée pour détecter les noms dans le texte brut qui lui est passé. Cette méthode accepte une variable String comme paramètre.

Appelez cette méthode en transmettant le format String de la phrase à cette méthode.

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

Étape 4: Impression de l'étendue des noms dans la phrase

le find() méthode de la NameFinderMEclass renvoie un tableau d'objets du type Span. La classe nommée Span of theopennlp.tools.util package est utilisé pour stocker le start et end entier d'ensembles.

Vous pouvez stocker les portées renvoyées par le find() dans le tableau Span et imprimez-les, comme indiqué dans le bloc de code suivant.

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

NER Example

Voici le programme qui lit la phrase donnée et reconnaît les portées des noms des personnes qu'elle contient. Enregistrez ce programme dans un fichier avec le nomNameFinderME_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());    
   }    
}

Compilez et exécutez le fichier Java enregistré à partir de l'invite de commande à l'aide des commandes suivantes -

javac NameFinderME_Example.java 
java NameFinderME_Example

Lors de l'exécution, le programme ci-dessus lit la chaîne donnée (texte brut), détecte les noms des personnes qu'elle contient et affiche leurs positions (étendues), comme indiqué ci-dessous.

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

Noms avec leurs positions

le substring() méthode de la classe String accepte le begin et le end offsetset renvoie la chaîne respective. Nous pouvons utiliser cette méthode pour imprimer les noms et leurs portées (positions) ensemble, comme indiqué dans le bloc de code suivant.

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

Voici le programme pour détecter les noms à partir du texte brut donné et les afficher avec leurs positions. Enregistrez ce programme dans un fichier avec le nomNameFinderSentences.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()]);      
   }    
}

Compilez et exécutez le fichier Java enregistré à partir de l'invite de commande à l'aide des commandes suivantes -

javac NameFinderSentences.java 
java NameFinderSentences

Lors de l'exécution, le programme ci-dessus lit la chaîne donnée (texte brut), détecte les noms des personnes qu'elle contient et affiche leurs positions (étendues) comme indiqué ci-dessous.

[0..1) person  Mike

Recherche des noms de l'emplacement

En chargeant divers modèles, vous pouvez détecter diverses entités nommées. Voici un programme Java qui charge leen-ner-location.binmodel et détecte les noms d'emplacement dans la phrase donnée. Enregistrez ce programme dans un fichier avec le nomLocationFinder.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()]); 
   }    
}

Compilez et exécutez le fichier Java enregistré à partir de l'invite de commande à l'aide des commandes suivantes -

javac LocationFinder.java 
java LocationFinder

Lors de l'exécution, le programme ci-dessus lit la chaîne donnée (texte brut), détecte les noms des personnes qu'elle contient et affiche leurs positions (étendues), comme indiqué ci-dessous.

[4..5) location  Hyderabad

Probabilité de NameFinder

le probs()méthode de la NameFinderME class est utilisé pour obtenir les probabilités de la dernière séquence décodée.

double[] probs = nameFinder.probs();

Voici le programme pour imprimer les probabilités. Enregistrez ce programme dans un fichier avec le nomTokenizerMEProbs.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]);          
   } 
}

Compilez et exécutez le fichier Java enregistré à partir de l'invite de commande à l'aide des commandes suivantes -

javac TokenizerMEProbs.java 
java TokenizerMEProbs

Lors de l'exécution, le programme ci-dessus lit la chaîne donnée, tokenise les phrases et les imprime. De plus, il renvoie également les probabilités de la dernière séquence décodée, comme indiqué ci-dessous.

[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

En utilisant OpenNLP, vous pouvez également détecter les parties du discours d'une phrase donnée et les imprimer. Au lieu du nom complet des parties du discours, OpenNLP utilise des formes courtes de chaque partie du discours. Le tableau suivant indique les différentes parties de discours détectées par OpenNLP et leur signification.

Parties du discours	Signification des parties du discours
NN	Nom, singulier ou masse
DT	Déterminant
VB	Verbe, forme de base
VBD	Verbe, passé
VBZ	Verbe, troisième personne du singulier présent
DANS	Préposition ou conjonction subordonnée
NNP	Nom propre, singulier
À	à
JJ	Adjectif

Marquer les parties du discours

Pour marquer les parties de discours d'une phrase, OpenNLP utilise un modèle, un fichier nommé en-posmaxent.bin. Il s'agit d'un modèle prédéfini qui est formé pour marquer les parties de la parole du texte brut donné.

le POSTaggerME classe de la opennlp.tools.postagpackage est utilisé pour charger ce modèle et étiqueter les parties de discours du texte brut donné à l'aide de la bibliothèque OpenNLP. Pour ce faire, vous devez -

• Chargez le en-pos-maxent.bin modèle utilisant le POSModel classe.

• Instancier le POSTaggerME classe.

• Tokenize la phrase.

• Générez les balises en utilisant tag() méthode.

• Imprimez les jetons et les balises en utilisant POSSample classe.

Voici les étapes à suivre pour écrire un programme qui marque les parties du discours dans le texte brut donné en utilisant le POSTaggerME classe.

Étape 1: Chargez le modèle

Le modèle de balisage POS est représenté par la classe nommée POSModel, qui appartient au package opennlp.tools.postag.

Pour charger un modèle de tokenizer -

• Créé un InputStream objet du modèle (instanciez le FileInputStream et passez le chemin du modèle au format String à son constructeur).

• Instancier le POSModel classe et passer le InputStream (objet) du modèle en tant que paramètre de son constructeur, comme indiqué dans le bloc de code suivant -

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

Étape 2: instanciation de la classe POSTaggerME

le POSTaggerME classe du package opennlp.tools.postagest utilisé pour prédire les parties du discours du texte brut donné. Il utilise l'Entropie maximale pour prendre ses décisions.

Instanciez cette classe et transmettez l'objet modèle créé à l'étape précédente, comme indiqué ci-dessous -

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

Étape 3: Tokeniser la phrase

le tokenize() méthode de la whitespaceTokenizerclass est utilisé pour tokeniser le texte brut qui lui est passé. Cette méthode accepte une variable String comme paramètre et renvoie un tableau de Strings (jetons).

Instancier le whitespaceTokenizer class et invoquez cette méthode en transmettant le format String de la phrase à cette méthode.

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

Étape 4: Générer les balises

le tag() méthode de la whitespaceTokenizerLa classe attribue des balises POS à la phrase des jetons. Cette méthode accepte un tableau de jetons (String) en tant que paramètre et renvoie une balise (tableau).

Invoquez le tag() méthode en lui passant les jetons générés à l'étape précédente.

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

Étape 5: Impression des jetons et des balises

le POSSampleclass représente la phrase étiquetée POS. Pour instancier cette classe, nous aurions besoin d'un tableau de jetons (du texte) et d'un tableau de balises.

le toString()La méthode de cette classe renvoie la phrase balisée. Instanciez cette classe en passant le jeton et les tableaux de balises créés aux étapes précédentes et appelez sontoString() méthode, comme indiqué dans le bloc de code suivant.

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

Example

Voici le programme qui marque les parties du discours dans un texte brut donné. Enregistrez ce programme dans un fichier avec le nomPosTaggerExample.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()); 
   
   } 
}

Compilez et exécutez le fichier Java enregistré à partir de l'invite de commande à l'aide des commandes suivantes -

javac PosTaggerExample.java 
java PosTaggerExample

Lors de l'exécution, le programme ci-dessus lit le texte donné et détecte les parties du discours de ces phrases et les affiche, comme indiqué ci-dessous.

Hi_NNP welcome_JJ to_TO Tutorialspoint_VB

Performances des étiqueteurs POS

Voici le programme qui balise les parties du discours d'un texte brut donné. Il surveille également les performances et affiche les performances du marqueur. Enregistrez ce programme dans un fichier avec le nomPosTagger_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();      
   } 
}

Compilez et exécutez le fichier Java enregistré à partir de l'invite de commande à l'aide des commandes suivantes -

javac PosTaggerExample.java 
java PosTaggerExample

Lors de l'exécution, le programme ci-dessus lit le texte donné et marque les parties de discours de ces phrases et les affiche. En outre, il surveille également les performances de l'étiqueteur de point de vente et l'affiche.

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

Probabilité des étiqueteurs POS

le probs() méthode de la POSTaggerME class est utilisé pour trouver les probabilités pour chaque balise de la phrase récemment balisée.

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

Voici le programme qui affiche les probabilités pour chaque balise de la dernière phrase balisée. Enregistrez ce programme dans un fichier avec le nomPosTaggerProbs.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]); 
   } 
}

Compilez et exécutez le fichier Java enregistré à partir de l'invite de commande à l'aide des commandes suivantes -

javac TokenizerMEProbs.java 
java TokenizerMEProbs

Lors de l'exécution, le programme ci-dessus lit le texte brut donné, balise les parties de discours de chaque jeton qu'il contient et les affiche. En outre, il affiche également les probabilités pour chaque partie du discours dans la phrase donnée, comme indiqué ci-dessous.

Hi_NNP welcome_JJ to_TO Tutorialspoint_VB    
0.6416834779738033 
0.42983612874819177 
0.8584513635863117 
0.4394784478206072

En utilisant l'API OpenNLP, vous pouvez analyser les phrases données. Dans ce chapitre, nous verrons comment analyser du texte brut à l'aide de l'API OpenNLP.

Analyse du texte brut à l'aide de la bibliothèque OpenNLP

Pour détecter les phrases, OpenNLP utilise un modèle prédéfini, un fichier nommé en-parserchunking.bin. Il s'agit d'un modèle prédéfini qui est formé pour analyser le texte brut donné.

le Parser classe de la opennlp.tools.Parser package est utilisé pour contenir les composants d'analyse et le ParserTool classe de la opennlp.tools.cmdline.parser package est utilisé pour analyser le contenu.

Voici les étapes à suivre pour écrire un programme qui analyse le texte brut donné en utilisant le ParserTool classe.

Étape 1: chargement du modèle

Le modèle d'analyse du texte est représenté par la classe nommée ParserModel, qui appartient au package opennlp.tools.parser.

Pour charger un modèle de tokenizer -

• Créé un InputStream objet du modèle (instanciez le FileInputStream et passez le chemin du modèle au format String à son constructeur).

• Instancier le ParserModel classe et passer le InputStream (objet) du modèle en tant que paramètre de son constructeur, comme indiqué dans le bloc de code suivant.

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

Étape 2: Création d'un objet de la classe Parser

le Parser classe du package opennlp.tools.parserreprésente une structure de données pour contenir les constituants d'analyse. Vous pouvez créer un objet de cette classe en utilisant le staticcreate() méthode de la ParserFactory classe.

Invoquez le create() méthode de la ParserFactory en passant l'objet modèle créé à l'étape précédente, comme indiqué ci-dessous -

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

Étape 3: analyse de la phrase

le parseLine() méthode de la ParserToolLa classe est utilisée pour analyser le texte brut dans OpenNLP. Cette méthode accepte -

• une variable String représentant le texte à analyser.

• un objet analyseur.

• un entier représentant le nombre d'analyses à effectuer.

Appelez cette méthode en transmettant à la phrase les paramètres suivants: l'objet d'analyse créé aux étapes précédentes et un entier représentant le nombre requis d'analyses à effectuer.

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

Example

Voici le programme qui analyse le texte brut donné. Enregistrez ce programme dans un fichier avec le nomParserExample.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();          
   } 
}

Compilez et exécutez le fichier Java enregistré à partir de l'invite de commande à l'aide des commandes suivantes -

javac ParserExample.java 
java ParserExample

Lors de l'exécution, le programme ci-dessus lit le texte brut donné, l'analyse et affiche la sortie suivante -

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

La segmentation d'une phrase se réfère à la division / division d'une phrase en parties de mots telles que des groupes de mots et des groupes de verbes.

Couper une phrase en utilisant OpenNLP

Pour détecter les phrases, OpenNLP utilise un modèle, un fichier nommé en-chunker.bin. Il s'agit d'un modèle prédéfini qui est formé pour fragmenter les phrases dans le texte brut donné.

le opennlp.tools.chunker package contient les classes et les interfaces qui sont utilisées pour rechercher des annotations syntaxiques non récursives telles que des fragments de phrases nominales.

Vous pouvez découper une phrase en utilisant la méthode chunk() du ChunkerMEclasse. Cette méthode accepte les jetons d'une phrase et les balises POS comme paramètres. Par conséquent, avant de commencer le processus de segmentation, vous devez d'abord Tokenize la phrase et générer les parties balises POS de celle-ci.

Pour découper une phrase en utilisant la bibliothèque OpenNLP, vous devez -

• Tokenize la phrase.

• Générez des balises POS pour cela.

• Chargez le en-chunker.bin modèle utilisant le ChunkerModel classe

• Instancier le ChunkerME classe.

• Coupez les phrases en utilisant le chunk() méthode de cette classe.

Voici les étapes à suivre pour écrire un programme pour découper des phrases à partir du texte brut donné.

Étape 1: Tokeniser la phrase

Tokenize les phrases en utilisant le tokenize() méthode de la whitespaceTokenizer class, comme indiqué dans le bloc de code suivant.

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

Étape 2: Génération des balises POS

Générez les balises POS de la phrase en utilisant le tag() méthode de la POSTaggerME class, comme indiqué dans le bloc de code suivant.

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

Étape 3: chargement du modèle

Le modèle de segmentation d'une phrase est représenté par la classe nommée ChunkerModel, qui appartient au package opennlp.tools.chunker.

Pour charger un modèle de détection de phrase -

• Créé un InputStream objet du modèle (instanciez le FileInputStream et passez le chemin du modèle au format String à son constructeur).

• Instancier le ChunkerModel classe et passer le InputStream (objet) du modèle en tant que paramètre de son constructeur, comme indiqué dans le bloc de code suivant -

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

Étape 4: Instanciation de la classe chunkerME

le chunkerME classe du package opennlp.tools.chunkercontient des méthodes pour découper les phrases. Il s'agit d'un bloc basé sur une entropie maximale.

Instanciez cette classe et transmettez l'objet modèle créé à l'étape précédente.

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

Étape 5: découper la phrase

le chunk() méthode de la ChunkerMEclass est utilisé pour fragmenter les phrases du texte brut qui lui est passé. Cette méthode accepte deux tableaux String représentant des jetons et des balises, en tant que paramètres.

Appelez cette méthode en passant le tableau de jetons et le tableau de balises créés au cours des étapes précédentes en tant que paramètres.

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

Example

Voici le programme pour découper les phrases dans le texte brut donné. Enregistrez ce programme dans un fichier avec le nomChunkerExample.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);         
   }    
}

Compilez et exécutez le fichier Java enregistré à partir de l'invite de commande à l'aide de la commande suivante -

javac ChunkerExample.java 
java ChunkerExample

Lors de l'exécution, le programme ci-dessus lit la chaîne donnée, segmente les phrases qu'elle contient et les affiche comme indiqué ci-dessous.

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

Détection des positions des jetons

Nous pouvons également détecter les positions ou les portées des morceaux en utilisant le chunkAsSpans() méthode de la ChunkerMEclasse. Cette méthode renvoie un tableau d'objets du type Span. La classe nommée Span of theopennlp.tools.util package est utilisé pour stocker le start et end entier d'ensembles.

Vous pouvez stocker les portées renvoyées par le chunkAsSpans() dans le tableau Span et imprimez-les, comme indiqué dans le bloc de code suivant.

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

Example

Voici le programme qui détecte les phrases dans le texte brut donné. Enregistrez ce programme dans un fichier avec le nomChunkerSpansEample.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());  
   }    
}

Compilez et exécutez le fichier Java enregistré à partir de l'invite de commande à l'aide des commandes suivantes -

javac ChunkerSpansEample.java 
java ChunkerSpansEample

Lors de l'exécution, le programme ci-dessus lit la chaîne donnée et s'étend sur les morceaux qu'elle contient, et affiche la sortie suivante -

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

Détection de probabilité de bloc

le probs() méthode de la ChunkerME class renvoie les probabilités de la dernière séquence décodée.

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

Voici le programme pour imprimer les probabilités de la dernière séquence décodée par le chunker. Enregistrez ce programme dans un fichier avec le nomChunkerProbsExample.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]);       
   }    
}

Compilez et exécutez le fichier Java enregistré à partir de l'invite de commande à l'aide des commandes suivantes -

javac ChunkerProbsExample.java 
java ChunkerProbsExample

Lors de l'exécution, le programme ci-dessus lit la chaîne donnée, la segmente et imprime les probabilités de la dernière séquence décodée.

0.9592746040797778 
0.6883933131241501 
0.8830563473996004 
0.8951150529746051

OpenNLP fournit une interface de ligne de commande (CLI) pour effectuer différentes opérations via la ligne de commande. Dans ce chapitre, nous prendrons quelques exemples pour montrer comment nous pouvons utiliser l'interface de ligne de commande OpenNLP.

Tokenisation

input.txt

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

Syntaxe

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

commander

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

production

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

Détection des phrases

input.txt

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

Syntaxe

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

commander

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

Production

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

Reconnaissance des entités nommées

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

Syntaxe

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

Commander

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

Production

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

Parties du balisage vocal

Input.txt

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

Syntaxe

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

Commander

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

Production

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