¿Cómo puedo dividir un texto en oraciones usando el analizador de Stanford?

¿Cómo puedo dividir un texto o párrafo en oraciones usando el analizador de Stanford ?

¿Hay algún método que pueda extraer oraciones, como getSentencesFromString() como se proporciona para Ruby ?

Puede verificar la clase DocumentPreprocessor. A continuación hay un pequeño fragmento. Creo que puede haber otras formas de hacer lo que quieras.

 String paragraph = "My 1st sentence. “Does it work for questions?” My third sentence."; Reader reader = new StringReader(paragraph); DocumentPreprocessor dp = new DocumentPreprocessor(reader); List sentenceList = new ArrayList(); for (List sentence : dp) { // SentenceUtils not Sentence String sentenceString = SentenceUtils.listToString(sentence); sentenceList.add(sentenceString); } for (String sentence : sentenceList) { System.out.println(sentence); } 

Sé que ya hay una respuesta aceptada … pero normalmente solo tomarías las SentenceAnnotations de un documento anotado.

 // creates a StanfordCoreNLP object, with POS tagging, lemmatization, NER, parsing, and coreference resolution 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 = ... // Add your text here! // 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 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); } } 

Fuente – http://nlp.stanford.edu/software/corenlp.shtml (a mitad de camino)

Y si solo busca oraciones, puede soltar los pasos posteriores como “analizar” y “dcoref” desde la inicialización de la interconexión, esto le ahorrará algo de carga y tiempo de procesamiento. Rock and roll. ~ K

Hay un par de problemas con la respuesta aceptada. Primero, el tokenizer transforma algunos caracteres, como el carácter “en los dos caracteres` `. Segundo, unir el texto tokenizado junto con el espacio en blanco no devuelve el mismo resultado que antes. Por lo tanto, el texto de ejemplo de la respuesta aceptada transforma el texto de entrada de formas no triviales.

Sin embargo, la clase CoreLabel que utiliza el tokenizer realiza un seguimiento de los caracteres fuente a los que están asignados, por lo que es trivial reconstruir la cadena adecuada, si tiene el original.

El Enfoque 1 a continuación muestra el enfoque de respuestas aceptadas, el Enfoque 2 muestra mi enfoque, que supera estos problemas.

 String paragraph = "My 1st sentence. “Does it work for questions?” My third sentence."; List sentenceList; /* ** APPROACH 1 (BAD!) ** */ Reader reader = new StringReader(paragraph); DocumentPreprocessor dp = new DocumentPreprocessor(reader); sentenceList = new ArrayList(); for (List sentence : dp) { sentenceList.add(Sentence.listToString(sentence)); } System.out.println(StringUtils.join(sentenceList, " _ ")); /* ** APPROACH 2 ** */ //// Tokenize List tokens = new ArrayList(); PTBTokenizer tokenizer = new PTBTokenizer(new StringReader(paragraph), new CoreLabelTokenFactory(), ""); while (tokenizer.hasNext()) { tokens.add(tokenizer.next()); } //// Split sentences from tokens List> sentences = new WordToSentenceProcessor().process(tokens); //// Join back together int end; int start = 0; sentenceList = new ArrayList(); for (List sentence: sentences) { end = sentence.get(sentence.size()-1).endPosition(); sentenceList.add(paragraph.substring(start, end).trim()); start = end; } System.out.println(StringUtils.join(sentenceList, " _ ")); 

Esto produce:

 My 1st sentence . _ `` Does it work for questions ? '' _ My third sentence . My 1st sentence. _ “Does it work for questions?” _ My third sentence. 

Uso del paquete .net C #: Esto dividirá las oraciones, corregirá los paréntesis y conservará los espacios y la puntuación originales:

 public class NlpDemo { public static readonly TokenizerFactory TokenizerFactory = PTBTokenizer.factory(new CoreLabelTokenFactory(), "normalizeParentheses=false,normalizeOtherBrackets=false,invertible=true"); public void ParseFile(string fileName) { using (var stream = File.OpenRead(fileName)) { SplitSentences(stream); } } public void SplitSentences(Stream stream) { var preProcessor = new DocumentPreprocessor(new UTF8Reader(new InputStreamWrapper(stream))); preProcessor.setTokenizerFactory(TokenizerFactory); foreach (java.util.List sentence in preProcessor) { ProcessSentence(sentence); } } // print the sentence with original spaces and punctuation. public void ProcessSentence(java.util.List sentence) { System.Console.WriteLine(edu.stanford.nlp.util.StringUtils.joinWithOriginalWhiteSpace(sentence)); } } 

Entrada: – Los caracteres de esta oración poseen cierto encanto, uno que a menudo se encuentra en la puntuación y la prosa. Esta es una segunda oración? Ciertamente así es.

Salida: 3 oraciones (‘?’ Se considera un delimitador al final de la oración)

Nota: para una frase como “la clase de la Sra. Havisham era impecable (¡hasta donde se podía ver!) En todos los aspectos”. El tokenizer discernirá correctamente que el período al final de Mrs. no es un EOS, ¡sin embargo marcará incorrectamente! dentro de los paréntesis como una EOS y dividir “en todos los aspectos”. como una segunda oración.

Con la API simple proporcionada por Stanford CoreNLP versión 3.6.0 o 3.7.0.

Aquí hay un ejemplo con 3.6.0. Funciona exactamente igual con 3.7.0.

Fragmento de código de Java

 import java.util.List; import edu.stanford.nlp.simple.Document; import edu.stanford.nlp.simple.Sentence; public class TestSplitSentences { public static void main(String[] args) { Document doc = new Document("The text paragraph. Another sentence. Yet another sentence."); List sentences = doc.sentences(); sentences.stream().forEach(System.out::println); } } 

Rendimientos:

El párrafo de texto.

Otra oración

Sin embargo, otra oración.

pom.xml

   4.0.0 stanfordcorenlp stanfordcorenlp 1.0-SNAPSHOT  1.8 1.8     edu.stanford.nlp stanford-corenlp 3.6.0    com.google.protobuf protobuf-java 2.6.1    

Puede usar Bastante fácil el etiquetador de Stanford para esto.

 String text = new String("Your text...."); //Your own text. List> tokenizedSentences = MaxentTagger.tokenizeText(new StringReader(text)); for(List act : tokenizedSentences) //Travel trough sentences { System.out.println(edu.stanford.nlp.ling.Sentence.listToString(act)); //This is your sentence } 

Puede usar el preprocesador de documentos . Es realmente fácil. Solo dale un nombre de archivo.

  for (List sentence : new DocumentPreprocessor(pathto/filename.txt)) { //sentence is a list of words in a sentence } 

Una variación en la respuesta @Kevin que resolverá la pregunta es la siguiente:

 for(CoreMap sentence: sentences) { String sentenceText = sentence.get(TextAnnotation.class) } 

que le proporciona la información de la oración sin molestarse con las otras anotaciones.

Otro elemento, no abordado excepto en algunas respuestas downvoted, es cómo establecer los delimitadores de oraciones? La forma más común, la predeterminada, es depender de los signos de puntuación comunes que indican el final de una oración. Hay otros formatos de documento que uno podría enfrentar al dibujar en corpus recostackdos, uno de los cuales siendo cada línea es su propia oración.

Para establecer sus delimitadores para DocumentPreprocessor como en las respuestas aceptadas, debería usar setSentenceDelimiter(String) . Para usar el enfoque de canalización sugerido como en la respuesta de @Kevin, uno trabajaría con las propiedades de ssplit. Por ejemplo, para usar el esquema de fin de línea propuesto en el párrafo anterior, uno establecería la propiedad ssplit.eolonly en true

Agregar ruta para el archivo de entrada y salida en el siguiente código: –

 import java.util.*; import edu.stanford.nlp.pipeline.*; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.io.PrintWriter; public class NLPExample { public static void main(String[] args) throws IOException { PrintWriter out; out = new PrintWriter("C:\\Users\\ACER\\Downloads\\stanford-corenlp-full- 2018-02-27\\output.txt"); Properties props=new Properties(); props.setProperty("annotators","tokenize, ssplit, pos,lemma"); StanfordCoreNLP pipeline = new StanfordCoreNLP(props); Annotation annotation; String readString = null; PrintWriter pw = null; BufferedReader br = null; br = new BufferedReader (new FileReader("C:\\Users\\ACER\\Downloads\\stanford- corenlp-full-2018-02-27\\input.txt" ) ) ; pw = new PrintWriter ( new BufferedWriter ( new FileWriter ( "C:\\Users\\ACER\\Downloads\\stanford-corenlp-full-2018-02- 27\\output.txt",false ))) ; String x = null; while (( readString = br.readLine ()) != null) { pw.println ( readString ) ; String xx=readString;x=xx;//System.out.println("OKKKKK"); annotation = new Annotation(x); pipeline.annotate(annotation); //System.out.println("LamoohAKA"); pipeline.prettyPrint(annotation, out); } br.close ( ) ; pw.close ( ) ; System.out.println("Done..."); } } 
 public class k { public static void main(String a[]){ String str = "This program splits a string based on space"; String[] words = str.split(" "); for(String s:words){ System.out.println(s); } str = "This program splits a string based on space"; words = str.split("\\s+"); } } 

Usa expresiones regulares para dividir texto en oraciones, en uso Regex pero en java no lo sé.

código

string [] sentences = Regex.Split (text, @ “(? <= ['" "a-za-z] [\)] [\. \! \?]) \ s + (? = [AZ])" );

90% funciona