[JAVA] NLP4J 100 Sprachverarbeitungsklopfen mit NLP4J # 34 Versuchen Sie, "A's B" intelligenter zu lösen (endgültige Ausgabe)

Zurück zum Index

Aufgabe

[NLP4J [006-034b] Versuchen Sie, mit NLP4J einen Annotator für die Verarbeitung von 100 Sprachen zu erstellen. Es war möglich, die Logik wiederzuverwenden, indem sie ausgeschnitten und definiert wurde.

Dies reicht jedoch noch nicht aus. Es fehlt an Flexibilität, da die Schlüsselwortextraktionsregeln in Logik geschrieben sind. Wenn es "B von A" ist, ist diese Logik in Ordnung, aber wenn Sie etwas wie "A ist B" extrahieren möchten, müssen Sie eine andere Logik vorbereiten.

Das Erstellen einer Programmlogikmethode zum Extrahieren von "A nach B" ist für das Studium in Ordnung, für die Verwendung der Verarbeitung natürlicher Sprache in Unternehmen jedoch nicht effizient.

/**
 *"Nomenklatur" wird in "Wort" geändert_nn_no_Als Schlüsselwort "nn" extrahieren.
 * @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("Substantiv")) {
				meishi_a = kwd;
			} //
			else if (meishi_a != null && no == null && kwd.getLex().equals("von")) {
				no = kwd;
			} //
			else if (meishi_a != null && no != null && kwd.getFacet().equals("Substantiv")) {
				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);
	}
}

Wie löst man

Sprachverarbeitung 100 Schläge 2015 Rückblickend auf # 34 ist # 34 einfach

"B von A" Extrahieren Sie die Nomenklatur, in der zwei Nomenklaturen durch "Nein" verbunden sind.

Ist nur geschrieben. Es ist nicht AI-ähnlich, Logik zu erstellen, nur um dieses Problem zu lösen.

Aus diesem Grund habe ich beschlossen, eine eigene Regelbeschreibung zu entwickeln.

Regelbeschreibung

Extrahieren Sie die Nomenklatur, in der zwei Nomenklaturen durch "Nein" verbunden sind.

Machen wir also eine Regel, nach der Sie dies schreiben können.

Wenn Sie es in den JSON schreiben, den jeder liebt, lauten die Regeln wie folgt.

[{'facet':'Substantiv'},{'lex':'von'},{'facet':'Substantiv'}]

Die Regeln für die Extraktion lauten, dass Schlüsselwörter als JSON-Array angeordnet sind und wie "Nase, nein, Nase" aussehen.

Beschreibung des Extraktionsergebnisses

Extrahieren Sie die Nomenklatur, in der zwei Nomenklaturen durch "Nein" verbunden sind.

Es ist jedoch nicht angegeben, was in der Nomenklatur extrahiert werden soll. Wenn Sie menschlich darüber nachdenken, nehmen wir an, dass es sich um die normale Form (Originalform) handelt.

Es gibt verschiedene Möglichkeiten, die Syntax als Beschreibungsregel für die Extraktionsergebnisse zu verwenden. Ich möchte sie jedoch im selben Format wie IBM Watson Explorer, die in Japan am häufigsten verwendete Text-Mining-Software für Unternehmen, beibehalten. (Mach es nicht JSON ...)

Die Dokumentation für die IBM Watson Explorer-Regeldatei lautet wie folgt: Benutzerdefinierte Regeldatei für die Sammlung von Inhaltsanalysen (https://www.ibm.com/support/knowledgecenter/de/SS5RWK_3.5.0/com.ibm.discovery.es.ta.doc/iiysatextanalrules.htm)

Obwohl es sich um ein schwieriges Handbuch handelt, können Sie den Teil zur Schlüsselwortextraktion wie folgt schreiben.

${0.lex}-${1.lex}-${2.lex}

Die Zahl ist der Indexwert des extrahierten Schlüsselworts. Die Zeichenfolge nach dem Punkt (hier lex) ist der Attributwert des Schlüsselworts. Lex bedeutet die ursprüngliche Form. Wenn ins Japanische übersetzt

${Prototyp des 0. Schlüsselworts}-${Prototyp des ersten Schlüsselworts}-${Prototyp des zweiten Schlüsselworts}

Es wird eine Beschreibung, dass die ursprüngliche Form des extrahierten Schlüsselworts mit einem Bindestrich verknüpft ist.

Da Sie alles andere als den Teil $ {...} beschreiben können, verketten Sie einfach

${0.lex}${1.lex}${2.lex}

Du kannst es schaffen

${0.lex} ... ${1.lex} ... ${2.lex}

Es kann auch als beschrieben werden.

CODE

Als Code

String rule = "[{facet:'Substantiv'},{lex:'von'},{facet:'Substantiv'}]";
String facet = "word_nn_no_nn";
String value = "${0.lex}-${1.lex}-${2.lex}";

Wenn Sie nur die Einstellung vorbereiten und damit extrahieren können, ist es klug. Es sieht ein bisschen wie KI aus. (Es wäre schlauer, wenn die Regeln in natürlicher Sprache geschrieben wären ...)

Als Annotator, der Schlüsselwörter gemäß den angegebenen Regeln extrahiert nlp4j.annotator.KeywordSequencePatternAnnotator Ich habe vorbereitet. Da der Code lang geworden ist, werde ich ihn hier weglassen.

String rule = "[{facet:'Substantiv'},{lex:'von'},{facet:'Substantiv'}]"; // #34 Nur das
String facet = "word_nn_no_nn"; // #34 Nur das
String value = "${0.lex}-${1.lex}-${2.lex}"; // #34 Nur das

//Verwenden Sie den von NLP4J bereitgestellten Textdatei-Crawler
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");

//Dokumentcrawl
List<Document> docs = crawler.crawlDocuments();

//Definition der NLP-Pipeline (Prozess durch Verbinden mehrerer Prozesse als Pipeline)
DocumentAnnotatorPipeline pipeline = new DefaultDocumentAnnotatorPipeline();
{
	// Yahoo!Annotator mit Japans API für morphologische Analyse
	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);
}
//Ausführung der Annotationsverarbeitung
pipeline.annotate(docs);

System.err.println("<Extrahierte Schlüsselwörter>");
for (Document doc : docs) {
	for (Keyword kwd : doc.getKeywords(facet)) {
		System.err.println(kwd);
	}
}
System.err.println("</Extrahierte Schlüsselwörter>");

Ergebnis

Es wurde wie folgt. Sie konnten Schlüsselwörter nur durch Angabe der Regeln extrahieren!

<Extrahierte Schlüsselwörter>
er-von-Palme[sequence=-1, facet=word_nn_no_nn, lex=er-von-Palme, str=er-von-Palme, reading=null, count=-1, begin=2, end=5, correlation=0.0]
Palme-von-Oben[sequence=-1, facet=word_nn_no_nn, lex=Palme-von-Oben, str=Palme-von-Oben, reading=null, count=-1, begin=0, end=3, correlation=0.0]
Schüler-von-Gesicht[sequence=-1, facet=word_nn_no_nn, lex=Schüler-von-Gesicht, str=Schüler-von-Gesicht, reading=null, count=-1, begin=11, end=15, correlation=0.0]
Sollte sein-von-Gesicht[sequence=-1, facet=word_nn_no_nn, lex=Sollte sein-von-Gesicht, str=Sollte sein-von-Gesicht, reading=null, count=-1, begin=13, end=17, correlation=0.0]
Gesicht-von-Mitte[sequence=-1, facet=word_nn_no_nn, lex=Gesicht-von-Mitte, str=Gesicht-von-Mitte, reading=null, count=-1, begin=5, end=9, correlation=0.0]
Loch-von-Während ~[sequence=-1, facet=word_nn_no_nn, lex=Loch-von-Während ~, str=Loch-von-Während ~, reading=null, count=-1, begin=6, end=9, correlation=0.0]
</Extrahierte Schlüsselwörter>

Maven

Der obige Code funktioniert mit nlp4j-core 1.2.0.0 und höher.

<dependency>
  <groupId>org.nlp4j</groupId>
  <artifactId>nlp4j-core</artifactId>
  <version>1.2.0.0</version>
</dependency>

Es scheint, dass 1.2.0.0 vom Erstellen + Hochladen bis zur Bereitstellung mit Maven mehr als 12 Stunden gedauert hat. Ist der Server ausgelastet? Es scheint, dass.

Impressionen

Ich denke, dass das Schreiben und Lösen von Regeln klüger ist als andere 100 Sprachverarbeitungsklopfen Nr. 34.

Zusammenfassung

Mit NLP4J können Sie ganz einfach die Verarbeitung natürlicher Sprache in Java durchführen!

Projekt-URL

https://www.nlp4j.org/ NLP4J_N_128.png

Zurück zum Index

Recommended Posts

NLP4J 100 Sprachverarbeitungsklopfen mit NLP4J # 34 Versuchen Sie, "A's B" intelligenter zu lösen (endgültige Ausgabe)
NLP4J Versuchen Sie, Annotator von 100 Sprachverarbeitung mit NLP4J auf # 34 "A B" zu bringen
NLP4J 100 Sprachverarbeitungsklopfen mit NLP4J # 34 "A B"
NLP4J 100 Sprachverarbeitungsklopfen mit NLP4J # 31 Verb
NLP4J 100 Sprachverarbeitungsklopfen mit NLP4J # 33
NLP4J 100 Sprachverarbeitungsklopfen mit NLP4J # 30 Lesen morphologischer Analyseergebnisse
Konvertieren Sie die C-Sprache mit Emscripten in JavaScript
NLP4J 100 Sprachverarbeitung mit NLP4J Knock # 32 Prototyp des Verbs