stanford de base de la pnl sortie java


Je suis un débutant avec Java et Stanford NLP toolkit et j'essaie de les utiliser pour un projet. Plus précisément, j'essaie d'utiliser Stanford Corenlp toolkit pour annoter un texte (avec Netbeans et non en ligne de commande) et j'ai essayé d'utiliser le code fourni sur http://nlp.stanford.edu/software/corenlp.shtml#Usage (En utilisant l'API CoreNLP de Stanford).. la question est: quelqu'un peut-il me dire comment je peux obtenir la sortie dans un fichier afin que je puisse la traiter davantage?

J'ai essayé d'imprimer les graphiques et le phrase à la console, juste pour voir le contenu. Qui fonctionne. Fondamentalement, ce dont j'aurais besoin, c'est de renvoyer le document annoté, afin que je puisse l'appeler à partir de ma classe principale et sortir un fichier texte (si c'est possible). J'essaie de regarder dans l'API de stanford corenlp, mais je ne sais pas vraiment quelle est la meilleure façon de retourner ce genre d'informations, compte tenu de mon manque d'expérience.

Voici le code:

Properties props = new Properties();
    props.put("annotators", "tokenize, ssplit, pos, lemma, ner, parse, dcoref");
    StanfordCoreNLP pipeline = new StanfordCoreNLP(props);

    // read some text in the text variable
    String text = "the quick fox jumps over the lazy dog";

    // create an empty Annotation just with the given text
    Annotation document = new Annotation(text);

    // run all Annotators on this text
    pipeline.annotate(document);

    // these are all the sentences in this document
    // a CoreMap is essentially a Map that uses class objects as keys and has values with custom types
    List<CoreMap> sentences = document.get(SentencesAnnotation.class);

    for(CoreMap sentence: sentences) {
      // traversing the words in the current sentence
      // a CoreLabel is a CoreMap with additional token-specific methods
      for (CoreLabel token: sentence.get(TokensAnnotation.class)) {
        // this is the text of the token
        String word = token.get(TextAnnotation.class);
        // this is the POS tag of the token
        String pos = token.get(PartOfSpeechAnnotation.class);
        // this is the NER label of the token
        String ne = token.get(NamedEntityTagAnnotation.class);       
      }

      // this is the parse tree of the current sentence
      Tree tree = sentence.get(TreeAnnotation.class);

      // this is the Stanford dependency graph of the current sentence
      SemanticGraph dependencies = sentence.get(CollapsedCCProcessedDependenciesAnnotation.class);
    }

    // This is the coreference link graph
    // Each chain stores a set of mentions that link to each other,
    // along with a method for getting the most representative mention
    // Both sentence and token offsets start at 1!
    Map<Integer, CorefChain> graph = 
      document.get(CorefChainAnnotation.class);
Author: SophieM, 2012-08-06

1 answers

Une fois que vous avez tout ou partie des analyses de langage naturel montrées dans votre exemple de code, tout ce que vous devez faire est de les envoyer dans un fichier de la manière Java normale, par exemple, avec un FileWriter pour la sortie au format texte. Concrètement, voici un exemple complet simple qui montre la sortie envoyée aux fichiers (si vous lui donnez des arguments de ligne de commande appropriés):

import java.io.*;
import java.util.*;

import edu.stanford.nlp.io.*;
import edu.stanford.nlp.ling.*;
import edu.stanford.nlp.pipeline.*;
import edu.stanford.nlp.trees.*;
import edu.stanford.nlp.util.*;

public class StanfordCoreNlpDemo {

  public static void main(String[] args) throws IOException {
    PrintWriter out;
    if (args.length > 1) {
      out = new PrintWriter(args[1]);
    } else {
      out = new PrintWriter(System.out);
    }
    PrintWriter xmlOut = null;
    if (args.length > 2) {
      xmlOut = new PrintWriter(args[2]);
    }

    StanfordCoreNLP pipeline = new StanfordCoreNLP();
    Annotation annotation;
    if (args.length > 0) {
      annotation = new Annotation(IOUtils.slurpFileNoExceptions(args[0]));
    } else {
      annotation = new Annotation("Kosgi Santosh sent an email to Stanford University. He didn't get a reply.");
    }

    pipeline.annotate(annotation);
    pipeline.prettyPrint(annotation, out);
    if (xmlOut != null) {
      pipeline.xmlPrint(annotation, xmlOut);
    }
    // An Annotation is a Map and you can get and use the various analyses individually.
    // For instance, this gets the parse tree of the first sentence in the text.
    List<CoreMap> sentences = annotation.get(CoreAnnotations.SentencesAnnotation.class);
    if (sentences != null && sentences.size() > 0) {
      CoreMap sentence = sentences.get(0);
      Tree tree = sentence.get(TreeCoreAnnotations.TreeAnnotation.class);
      out.println();
      out.println("The first sentence parsed is:");
      tree.pennPrint(out);
    }
  }

}
 24
Author: Christopher Manning, 2012-08-11 21:10:52