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

Sé que ya hay una respuesta aceptada...pero normalmente solo tomarías las notas de sentencia 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<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);       
  }

}

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

Y si solo está buscando oraciones, puede eliminar los pasos posteriores como "parse" y "dcoref" de la inicialización de la canalización, le ahorrará algo de tiempo de carga y procesamiento. Rock and roll. ~K

Hay un par de problemas con la respuesta aceptada. Primero, el tokenizador transforma algunos caracteres , como el carácter "en los dos caracteres". En segundo lugar, unir el texto tokenizado con espacios 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 maneras no triviales.

Sin embargo, la clase CoreLabel que usa el tokenizador realiza un seguimiento de los caracteres de origen a los que están mapeados, por lo que es trivial para 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<String> sentenceList;

/* ** APPROACH 1 (BAD!) ** */
Reader reader = new StringReader(paragraph);
DocumentPreprocessor dp = new DocumentPreprocessor(reader);
sentenceList = new ArrayList<String>();
for (List<HasWord> sentence : dp) {
    sentenceList.add(Sentence.listToString(sentence));
}
System.out.println(StringUtils.join(sentenceList, " _ "));

/* ** APPROACH 2 ** */
//// Tokenize
List<CoreLabel> tokens = new ArrayList<CoreLabel>();
PTBTokenizer<CoreLabel> tokenizer = new PTBTokenizer<CoreLabel>(new StringReader(paragraph), new CoreLabelTokenFactory(), "");
while (tokenizer.hasNext()) {
    tokens.add(tokenizer.next());
}
//// Split sentences from tokens
List<List<CoreLabel>> sentences = new WordToSentenceProcessor<CoreLabel>().process(tokens);
//// Join back together
int end;
int start = 0;
sentenceList = new ArrayList<String>();
for (List<CoreLabel> 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.

Usando el paquete. net C# : Esto dividirá oraciones, corregirá los paréntesis y preservará los espacios originales y la puntuación:

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 frase poseen un cierto encanto, que a menudo se encuentra en la puntuación y la prosa. Esta es una segunda frase? De hecho lo es.

Salida: 3 frases ('?"se considera un delimitador de fin de frase)

Nota: para una oración como "La clase de la Sra. Havisham fue impecable (en la medida en que se pudo ¡ves!) en todos los aspectos."El tokenizador discernirá correctamente que el período al final de la señora no es un EOS, sin embargo, marcará incorrectamente el ! dentro de los paréntesis como una EOS y dividir "en todos los aspectos."como segunda frase.

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 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<Sentence> sentences = doc.sentences();
        sentences.stream().forEach(System.out::println);
    }
}

Rinde:

El párrafo de texto.

Otra oración.

Otra frase.

Pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>stanfordcorenlp</groupId>
    <artifactId>stanfordcorenlp</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/edu.stanford.nlp/stanford-corenlp -->
        <dependency>
            <groupId>edu.stanford.nlp</groupId>
            <artifactId>stanford-corenlp</artifactId>
            <version>3.6.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.google.protobuf/protobuf-java -->
        <dependency>
            <groupId>com.google.protobuf</groupId>
            <artifactId>protobuf-java</artifactId>
            <version>2.6.1</version>
        </dependency>
    </dependencies>
</project>

Usted puede bastante fácil usar Stanford tagger para esto.

String text = new String("Your text....");  //Your own text.
List<List<HasWord>> tokenizedSentences = MaxentTagger.tokenizeText(new StringReader(text));

for(List<CoreLabel> 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 muy fácil. Sólo dale un nombre de archivo.

    for (List<HasWord> 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 obtiene la información de la oración sin molestarse con los otros anotadores.

Otro elemento, que no se aborda excepto en unas pocas respuestas con votos negativos, 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 documentos que uno podría enfrentar al dibujar sobre corpus reunidos, uno de los cuales es que cada línea es su propia oración.

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

Agregue la 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+");
}
}

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

Código

String [] sentences = Regex.Split(texto, @"(?

90% funciona