java - the - stanford''s core nlp suite

stanford core nlp salida java

Question

Soy un novato en Java y Stanford NLP toolkit y trato de usarlos para un proyecto. Específicamente, estoy tratando de usar el juego de herramientas Stanford Corenlp para anotar un texto (con Netbeans y no con línea de comandos) y traté de usar el código provisto en http://nlp.stanford.edu/software/corenlp.shtml#Usage ( Usando la API CoreNLP de Stanford) ... la pregunta es: ¿alguien puede decirme cómo puedo obtener la salida en un archivo para poder procesarlo?

He intentado imprimir los gráficos y la oración en la consola, solo para ver el contenido. Eso funciona. Básicamente, lo que necesitaría es devolver el documento anotado, de modo que pueda llamarlo desde mi clase principal y generar un archivo de texto (si es posible). Estoy tratando de buscar en la API de stanford corenlp, pero realmente no sé cuál es la mejor manera de devolver este tipo de información, dada mi falta de experiencia.

Aquí está el código:

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

Answer 1

Una vez que tenga alguno o todos los análisis de lenguaje natural que se muestran en su ejemplo de código, todo lo que debe hacer es enviarlos a un archivo en la forma normal de Java, por ejemplo, con un FileWriter para la salida en formato de texto. Concretamente, aquí hay un ejemplo completo y sencillo que muestra la salida enviada a los archivos (si le da los argumentos de línea de comandos apropiados):

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