-
Notifications
You must be signed in to change notification settings - Fork 20
API CoGrOO 4
William Daniel Colen de Moura Silva edited this page Apr 18, 2017
·
3 revisions
Inclua a seguinte configuração no seu projeto Maven:
<project>
...
<dependencies>
<dependency>
<groupId>org.cogroo.lang.pt_br</groupId>
<artifactId>cogroo-ann-pt_br</artifactId>
<version>4.0.0</version>
</dependency>
</dependencies>
...
</project>Nota: se não conhece o Maven leia Maven Getting Started Guide, principalmente os itens How do I setup Maven?, How do I make my first Maven project?, How do I compile my application sources? e How do I use external dependencies?.
Deseja compilar o código fonte? Seu projeto não usa Maven? Veja como proceder em Ambiente_de_Desenvolvimento [todo]
Este exemplo processa um texto do usuário usando o pipe padrão do CoGrOO.
Primeiro criamos o pipe usando as configurações de idioma:
ComponentFactory factory = ComponentFactory.create(new Locale("pt", "BR"));
Analyzer cogroo = factory.createPipe();Crie um objeto do tipo Document e inclua o texto que será processado:
Document document = new DocumentImpl();
document.setText(documentText);O documento será anotado com o comando:
cogroo.analyze(document);Usando os getters do documento é possível obter as anotações:
for (Sentence sentence : document.getSentences()) { // lista de sentenças
sentence.getStart(); sentence.getEnd(); // caracteres onde a sentença começa e termina
sentence.getText(); // texto da sentença
// Tokens
for (Token token : sentence.getTokens()) { // lista de tokens
token.getStart(); token.getEnd(); // caracteres onde o token começa e termina
token.getLexeme(); // o texto do token
token.getLemmas(); // um array com os possíveis lemas para o par lexeme+postag
token.getPOSTag(); // classe morfológica de acordo com o contexto
token.getFeatures(); // gênero, número, tempo etc
}
// Chunks
for (Chunk chunk : sentence.getChunks()) { // lista de chunks
chunk.getStart(); chunk.getEnd(); // índice do token onde o chunk começa e do token onde ele termina
chunk.getTag(); // the chunk tag
chunk.getTokens(); // a list with the covered tokens
}
// Structure
for (SyntacticChunk structure : sentence.getSyntacticChunks()) { // lista de SyntacticChunks
structure.getStart(); structure.getEnd(); // índice do token onde o structure começa e do token onde ele termina
structure.getTag(); // the structure tag
structure.getTokens(); // a list with the covered tokens
}
}Nota: etiquetas seguem as definições do Floresta Sintáctica . Tome como referência o item "2.3. Word classes (terminals)" para classe morfológica, e "3. Morphological information" para features.
O arquivo anexado é um projeto exemplo que usa a API. Após descompactar, faça um build e execute com os comandos:
mvn install
mvn exec:java -Dexec.mainClass="org.cogroo.examples.Example" src/main/java/org/cogroo/examples/Example.java
package org.cogroo.examples;
import java.util.Arrays;
import java.util.Locale;
import java.util.Scanner;
import org.cogroo.analyzer.Analyzer;
import org.cogroo.analyzer.ComponentFactory;
import org.cogroo.text.Chunk;
import org.cogroo.text.Document;
import org.cogroo.text.Sentence;
import org.cogroo.text.SyntacticChunk;
import org.cogroo.text.Token;
import org.cogroo.text.impl.DocumentImpl;
/**
* CoGrOO 4.0.0-SNAPSHOT usage example
*/
public class Example {
/** the CoGrOO pipe instance */
private Analyzer cogroo;
public Example() {
/*
* The following command creates a component factory given a locale. The
* locale will be resolved as a configuration file in the classpath with the
* following pattern: /models_lang_COUNTRY. Another option is to use the
* method ComponentFactory.create(InputStream) directly.
*/
ComponentFactory factory = ComponentFactory.create(new Locale("pt", "BR"));
/*
* Create the default pipe, which is complete, including from sentence
* detection to featurization.
*/
cogroo = factory.createPipe();
}
/**
* Creates a document and set the imput text. Finally analyze it using the
* pipe
*/
public void analyzeAndPrintDocument(String documentText) {
// Create a document and set the text.
Document document = new DocumentImpl();
document.setText(documentText);
// lets measure the time...
long start = System.nanoTime();
// analyze it
cogroo.analyze(document);
System.out.println("Document processed in "
+ ((System.nanoTime() - start) / 1000000) + "ms");
print(document);
}
/** A utility method that prints the analyzed document to the std output. */
private void print(Document document) {
StringBuilder output = new StringBuilder();
// and now we navigate the document to print its data
for (Sentence sentence : document.getSentences()) {
// Print the sentence. You can also get the sentence span annotation.
output.append("Sentence: ").append(sentence.getText()).append("\n");
output.append(" Tokens: \n");
// for each token found...
for (Token token : sentence.getTokens()) {
String lexeme = token.getLexeme();
String lemmas = Arrays.toString(token.getLemmas());
String pos = token.getPOSTag();
String feat = token.getFeatures();
output.append(String.format(" %-10s %-12s %-6s %-10s\n", lexeme,
lemmas, pos, feat));
}
// we can also print the chunks, but printing it is not that easy!
output.append(" Chunks: ");
for (Chunk chunk : sentence.getChunks()) {
output.append("[").append(chunk.getTag()).append(": ");
for (Token innerToken : chunk.getTokens()) {
output.append(innerToken.getLexeme()).append(" ");
}
output.append("] ");
}
output.append("\n");
// we can also print the shallow parsing results!
output.append(" Shallow Structure: ");
for (SyntacticChunk structure : sentence.getSyntacticChunks()) {
output.append("[").append(structure.getTag()).append(": ");
for (Token innerToken : structure.getTokens()) {
output.append(innerToken.getLexeme()).append(" ");
}
output.append("] ");
}
output.append("\n");
}
System.out.println(output.toString());
}
/**
* @param args
*/
public static void main(String[] args) {
Example ex = new Example();
Scanner kb = new Scanner(System.in);
System.out.print("Enter the sentence or 'q' to quit: ");
String input = kb.nextLine();
while (!input.equals("q")) {
ex.analyzeAndPrintDocument(input);
System.out.print("Enter the sentence or 'q' to quit: ");
input = kb.nextLine();
}
}
}src/main/resources/models_pt_BR.xml (do projeto cogroo-base)
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<languageConfiguration xmlns:jxb="http://java.sun.com/xml/ns/jaxb"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="languageConfiguration.xsd">
<locale>pt_BR</locale>
<model type="sentenceDetector">/models/pt-sent.model</model>
<model type="tokenizer">/models/pt-tok.model</model>
<model type="nameFinder">/models/pt-prop.model</model>
<model type="contractionFinder">/models/pt-con.model</model>
<model type="posTagger">/models/pt-pos.model</model>
<model type="featurizer">/models/pt-feat.model</model>
<model type="chunker">/models/pt-chunk.model</model>
<model type="headFinder">/models/pt-hf.model</model>
<model type="shallowParser">/models/pt-sp.model</model>
<pipe>
<analyzer>sentenceDetector</analyzer>
<analyzer>tokenizer</analyzer>
<analyzer>nameFinder</analyzer>
<analyzer>contractionFinder</analyzer>
<analyzer>posTagger</analyzer>
<analyzer>featurizer</analyzer>
<analyzer>lemmatizer</analyzer>
<analyzer>chunker</analyzer>
<analyzer>headFinder</analyzer>
<analyzer>shallowParser</analyzer>
</pipe>
</languageConfiguration> Existem diversas maneiras de personalizar o CoGrOO. Sugestões:
Você pode criar um novo models.xml e alterar os elementos model, trocando um modelo, ou eliminando elementos do pipe. Note que os modelos devem estar no classpath.
Neste exemplo o pipe não tem o featurizer, e trocamos o modelo do posTagger:
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<languageConfiguration xmlns:jxb="http://java.sun.com/xml/ns/jaxb"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="languageConfiguration.xsd">
<locale>pt_BR</locale>
<model type="sentenceDetector">/models/pt-sent.model</model>
<model type="tokenizer">/models/pt-tok.model</model>
<model type="nameFinder">/models/pt-prop.model</model>
<model type="contractionFinder">/models/pt-con.model</model>
<model type="posTagger">/custom_models/pt-pos.model</model>
<model type="featurizer">/models/pt-feat.model</model>
<pipe>
<analyzer>sentenceDetector</analyzer>
<analyzer>tokenizer</analyzer>
<analyzer>nameFinder</analyzer>
<analyzer>contractionFinder</analyzer>
<analyzer>posTagger</analyzer>
<analyzer>lemmatizer</analyzer>
</pipe>
</languageConfiguration>Crie um InputStream com o XML e use para criar um ComponentFactory:
InputStream in = new FileInputStream("models.xml");
ComponentFactory factory = ComponentFactory.create(in);
in.close();
Analyzer cogroo = factory.createPipe();O projeto exemplo inclui uma classe que usa um custom pipe:
src/main/java/org/cogroo/examples/ExampleCustomPipe.java
src/main/resources/models_customPipe.xml
Para executar:
mvn exec:java -Dexec.mainClass="org.cogroo.examples.ExampleCustomPipe" Para usar a API do corretor gramatical você precisa da seguinte configuração no seu projeto Maven. O elemento é necessário apenas se estiver usando uma versão SNAPSHOT.
<project>
...
<dependencies>
<dependency>
<groupId>org.cogroo.lang.pt_br</groupId>
<artifactId>cogroo-gc-pt_br</artifactId>
<version>4.0.0</version>
</dependency>
</dependencies>
...
</project>Para inicializar o corretor gramatical crie um Pipe padrão para o idioma e insira nesse pipe um objeto GrammarCheckerAnalyzer:
// inicializamos os analisadores
ComponentFactory factory = ComponentFactory.create(new Locale("pt", "BR"));
// criamos o GrammarChecker
GrammarChecker gc = new GrammarChecker(pipe);Para verificar um documento:
// crie um CheckDocument com o texto:
CheckDocument document = new CheckDocument("Fomos levados à crer. As bonecas são bonita.");
// passe o doc pelo pipe
gc.analyze(document);
// obtenha os resultados em document.getMistakes(), ou simplesmente imprima o documento
System.out.println(document);