[JAVA] NLP4J [006-034c] 100 coups de traitement du langage avec NLP4J # 34 Essayez de résoudre plus intelligemment "A's B" (édition finale)
Tâche
NLP4J [006-034b] Faisons un Annotateur pour 100 traitements de langage frapper # 34 "A's B" avec NLP4J Il était possible de réutiliser la logique en la découpant et en la définissant.
Cependant, cela ne suffit toujours pas. Il manque de flexibilité car les règles d'extraction de mots-clés sont écrites en logique. Si c'est "B of A", cette logique est bonne, mais si vous voulez extraire quelque chose comme "A is B", vous devez préparer une autre logique.
Créer une méthode de logique de programme juste pour extraire "A vers B" est bien pour l'étude, mais ce n'est pas efficace pour utiliser le traitement du langage naturel en entreprise.
/**
*"Nomenclature" est remplacé par "mot"_nn_no_Extraire en tant que mot clé "nn".
* @author Hiroki Oya
*/
public class Nokku34Annotator extends AbstractDocumentAnnotator implements DocumentAnnotator {
@Override
public void annotate(Document doc) throws Exception {
ArrayList<Keyword> newkwds = new ArrayList<>();
Keyword meishi_a = null;
Keyword no = null;
for (Keyword kwd : doc.getKeywords()) {
if (meishi_a == null && kwd.getFacet().equals("nom")) {
meishi_a = kwd;
} //
else if (meishi_a != null && no == null && kwd.getLex().equals("de")) {
no = kwd;
} //
else if (meishi_a != null && no != null && kwd.getFacet().equals("nom")) {
Keyword kw = new DefaultKeyword();
kwd.setLex(meishi_a.getLex() + no.getLex() + kwd.getLex());
kwd.setFacet("word_nn_no_nn");
kwd.setBegin(meishi_a.getBegin());
kwd.setEnd(kwd.getEnd());
kwd.setStr(meishi_a.getStr() + no.getStr() + kwd.getStr());
kwd.setReading(meishi_a.getReading() + no.getReading() + kwd.getReading());
newkwds.add(kw);
meishi_a = null;
no = null;
} //
else {
meishi_a = null;
no = null;
}
}
doc.addKeywords(newkwds);
}
}
Comment résoudre
Traitement du langage 100 coups 2015 En regardant en arrière à # 34, # 34 est simplement
"B de A" Extraire la nomenclature dans laquelle deux nomenclatures sont reliées par "non"
Est seulement écrit. Ce n'est pas comme l'IA de créer une logique juste pour résoudre ce problème.
Par conséquent, j'ai décidé de développer ma propre description de règle.
Description de la règle
Extraire la nomenclature dans laquelle deux nomenclatures sont reliées par "non"
Alors faisons une règle qui vous permet d'écrire ceci.
Si vous l'écrivez dans le JSON que tout le monde aime, les règles sont les suivantes.
[{'facet':'nom'},{'lex':'de'},{'facet':'nom'}]
Les règles d'extraction sont que les mots-clés sont alignés comme un tableau JSON et ressemblent à "nose, no, nose".
Description du résultat d'extraction
Extraire la nomenclature dans laquelle deux nomenclatures sont reliées par "non"
Cependant, il n'est pas précisé ce qu'il faut extraire dans la nomenclature. Si vous y pensez humainement, supposons qu'il s'agit de la forme normale (forme originale).
Il existe différentes manières d'utiliser la syntaxe comme règle de description des résultats d'extraction, mais j'aimerais la conserver dans le même format qu'IBM Watson Explorer, le logiciel d'exploration de texte d'entreprise le plus utilisé au Japon. (Ne le faites pas en JSON ...)
La documentation du fichier de règles IBM Watson Explorer est la suivante: Fichier de règles personnalisées pour la collecte d'analyse de contenu (https://www.ibm.com/support/knowledgecenter/en/SS5RWK_3.5.0/com.ibm.discovery.es.ta.doc/iiysatextanalrules.htm)
Bien que ce soit un manuel difficile, la manière d'écrire la partie d'extraction de mot-clé est la suivante.
${0.lex}-${1.lex}-${2.lex}
Le nombre est la valeur d'index du mot-clé extrait. La chaîne suivant le point (ici lex) est la valeur d'attribut du mot-clé. lex signifie la forme originale. Une fois traduit en japonais
${Prototype du 0ème mot-clé}-${Prototype du premier mot-clé}-${Prototype du deuxième mot-clé}
Cela devient une description que la forme originale du mot-clé extrait est concaténée avec un trait d'union.
Puisque vous pouvez décrire autre chose que la partie $ {...}, concaténez simplement
${0.lex}${1.lex}${2.lex}
Tu peux le faire
${0.lex} ... ${1.lex} ... ${2.lex}
Il peut également être décrit comme.
CODE
En tant que code
String rule = "[{facet:'nom'},{lex:'de'},{facet:'nom'}]";
String facet = "word_nn_no_nn";
String value = "${0.lex}-${1.lex}-${2.lex}";
Si vous ne pouvez préparer que le réglage et extraire avec cela, ce sera intelligent. Cela ressemble un peu à l'IA. (Ce serait plus intelligent si les règles étaient écrites en langage naturel ...)
En tant qu'annotateur qui extrait les mots-clés selon les règles spécifiées nlp4j.annotator.KeywordSequencePatternAnnotator J'ai préparé. Puisque le code est devenu long, je vais l'omettre ici.
String rule = "[{facet:'nom'},{lex:'de'},{facet:'nom'}]"; // #34 Seulement ceci
String facet = "word_nn_no_nn"; // #34 Seulement ceci
String value = "${0.lex}-${1.lex}-${2.lex}"; // #34 Seulement ceci
//Utilisez le robot d'exploration de fichiers texte fourni par NLP4J
Crawler crawler = new TextFileLineSeparatedCrawler();
crawler.setProperty("file", "src/test/resources/nlp4j.crawler/neko_short_utf8.txt");
crawler.setProperty("encoding", "UTF-8");
crawler.setProperty("target", "text");
//Exploration de documents
List<Document> docs = crawler.crawlDocuments();
//Définition du pipeline NLP (processus en connectant plusieurs processus en tant que pipeline)
DocumentAnnotatorPipeline pipeline = new DefaultDocumentAnnotatorPipeline();
{
// Yahoo!Annotateur utilisant l'API d'analyse morphologique du Japon
DocumentAnnotator annotator = new YJpMaAnnotator();
pipeline.add(annotator);
}
{
KeywordSequencePatternAnnotator annotator = new KeywordSequencePatternAnnotator();
annotator.setProperty("rule[0]", rule);
annotator.setProperty("facet[0]", facet);
annotator.setProperty("value[0]", value);
pipeline.add(annotator);
}
//Exécution du traitement des annotations
pipeline.annotate(docs);
System.err.println("<Mots-clés extraits>");
for (Document doc : docs) {
for (Keyword kwd : doc.getKeywords(facet)) {
System.err.println(kwd);
}
}
System.err.println("</Mots-clés extraits>");
résultat
C'est devenu comme suit. Vous avez pu extraire des mots-clés simplement en spécifiant les règles!
<Mots-clés extraits>
il-de-paume[sequence=-1, facet=word_nn_no_nn, lex=il-de-paume, str=il-de-paume, reading=null, count=-1, begin=2, end=5, correlation=0.0]
paume-de-Vers le haut[sequence=-1, facet=word_nn_no_nn, lex=paume-de-Vers le haut, str=paume-de-Vers le haut, reading=null, count=-1, begin=0, end=3, correlation=0.0]
Étudiant-de-visage[sequence=-1, facet=word_nn_no_nn, lex=Étudiant-de-visage, str=Étudiant-de-visage, reading=null, count=-1, begin=11, end=15, correlation=0.0]
Devrait être-de-visage[sequence=-1, facet=word_nn_no_nn, lex=Devrait être-de-visage, str=Devrait être-de-visage, reading=null, count=-1, begin=13, end=17, correlation=0.0]
visage-de-milieu[sequence=-1, facet=word_nn_no_nn, lex=visage-de-milieu, str=visage-de-milieu, reading=null, count=-1, begin=5, end=9, correlation=0.0]
trou-de-Pendant ~[sequence=-1, facet=word_nn_no_nn, lex=trou-de-Pendant ~, str=trou-de-Pendant ~, reading=null, count=-1, begin=6, end=9, correlation=0.0]
</Mots-clés extraits>
Maven
Le code ci-dessus fonctionne avec nlp4j-core 1.2.0.0 et supérieur.
<dependency>
<groupId>org.nlp4j</groupId>
<artifactId>nlp4j-core</artifactId>
<version>1.2.0.0</version>
</dependency>
Il semble que la version 1.2.0.0 ait pris plus de 12 heures entre la version build + upload et le déploiement avec Maven. Le serveur est-il occupé? Il semble.
Impressions
Je pense que l'écriture et la résolution de règles sont plus intelligentes que les autres traitements linguistiques 100 knock # 34.
Résumé
Avec NLP4J, vous pouvez facilement effectuer le traitement du langage naturel en Java!
URL du projet
https://www.nlp4j.org/
Recommended Posts