Lemma Generierung mit Stanford CoreNLP in Java

In der natürlichen Sprachverarbeitung (NLP) ist die Generierung von Lemmas ein wichtiger Schritt, um die Grundform von Wörtern zu ermitteln und somit die Flexionsformen zu vereinfachen. In diesem Artikel werden wir die LemmaExample-Klasse vorstellen, die es Ihnen ermöglicht, Lemmas mit Stanford CoreNLP in Java zu generieren.

Die Pipeline-Klasse

Wie im vorherigen Artikel erklärt, ist die Pipeline-Klasse entscheidend für die Einrichtung der NLP-Pipeline mit Stanford CoreNLP. Sie enthält eine Liste von Eigenschaften, die festlegen, welche Schritte der NLP-Analyse durchgeführt werden sollen. In diesem Beispiel haben wir die Eigenschaften auf „tokenize, ssplit, pos, lemma, ner, parse, sentiment, depparse“ gesetzt, um auch die Lemma-Generierung zu aktivieren.

package de.lernjava.nlp;

import java.util.Properties;
import edu.stanford.nlp.pipeline.StanfordCoreNLP;

public class Pipeline {

    private static Properties properties;
    private  static String propertiesName = "tokenize, ssplit, pos, lemma, ner, parse, sentiment, depparse";
    private static StanfordCoreNLP stanfordCoreNLP;

    private Pipeline() {

    }

    static {
        properties = new Properties();
        properties.setProperty("annotators", propertiesName);
    }

    public static StanfordCoreNLP getPipeline() {
        if (stanfordCoreNLP == null) {
            stanfordCoreNLP = new StanfordCoreNLP(properties);
        }
        return stanfordCoreNLP;
    }

}

Die LemmaExample-Klasse

Die LemmaExample-Klasse demonstriert die Generierung von Lemmas für einen gegebenen Text. In unserem Beispiel haben wir den Text definiert: „An airplane is assigned to several flights. This flight is assigned to only one airplane. A pilot can perform several flights. A flight is performed by several pilots.“

Zuerst wird die Stanford CoreNLP-Pipeline mit der Methode Pipeline.getPipeline() initialisiert. Dann wird ein CoreDocument-Objekt erstellt und mit dem Text initialisiert. Anschließend wird die stanfordCoreNLP.annotate(coreDocument)-Methode aufgerufen, um die NLP-Analyse durchzuführen, einschließlich der Lemma-Generierung.

package de.lernjava.nlp;

import edu.stanford.nlp.pipeline.CoreDocument;
import edu.stanford.nlp.pipeline.StanfordCoreNLP;
import edu.stanford.nlp.ling.CoreLabel;

import java.util.List;

public class LemmaExample {

    public static void main(String[] args) {

            StanfordCoreNLP stanfordCoreNLP = Pipeline.getPipeline();
            String text = "An airplane is assigned to several flights. This flight is assigned to only one airplane. A pilot can perform several flights. A flight is performed by several pilots.";

            CoreDocument coreDocument = new CoreDocument(text);
            stanfordCoreNLP.annotate(coreDocument);

            List<CoreLabel> coreLabelList = coreDocument.tokens();
            for(CoreLabel coreLabel : coreLabelList) {
                String lemma = coreLabel.lemma();
                System.out.print(coreLabel.originalText() + "(" + lemma + ") ");
            }
    }
}

Die coreDocument.tokens()-Methode gibt eine Liste von CoreLabel-Objekten zurück, die die einzelnen Token im Text repräsentieren. Mit einer einfachen Schleife können wir durch diese Liste iterieren und für jedes Token das ursprüngliche Textwort und das dazugehörige Lemma ausgeben, indem wir coreLabel.originalText() und coreLabel.lemma() aufrufen. Der Output der Klasse lautet wie folgt, wobei das Lemma immer in Klammern hinter dem Wort angegeben wird:

An(a) airplane(airplane) is(be) assigned(assign) to(to) several(several) flights(flight) .(.) This(this) flight(flight) is(be) assigned(assign) to(to) only(only) one(one) airplane(airplane) .(.) A(a) pilot(pilot) can(can) perform(perform) several(several) flights(flight) .(.) A(a) flight(flight) is(be) performed(perform) by(by) several(several) pilots(pilot) .(.) 

Zusammenfassung

Dank der LemmaExample-Klasse und der Nutzung von Stanford CoreNLP können Sie in Java effektiv Lemmas generieren und somit die Flexionsformen von Wörtern vereinfachen. Die Pipeline-Klasse ermöglicht die einfache Konfiguration der NLP-Pipeline, einschließlich der Lemma-Generierung. Mit diesem Verständnis können Sie Ihre NLP-Analysen verbessern und komplexe Sprachverarbeitungsaufgaben in Java bewältigen. Probieren Sie es selbst aus und entdecken Sie die vielseitigen Möglichkeiten von Stanford CoreNLP für Ihre Java-Anwendungen!