API CoGrOO 4x

Configurando o pom.xml

Inclua a seguinte configuração no seu projeto Maven. Se deseja usar versões RELEASE não é necessário incluir o elemento <repositories>:

 1<project>
 2    ...
 3    <dependencies>
 4        <dependency>
 5            <groupId>org.cogroo.lang.pt_br</groupId>
 6            <artifactId>cogroo-ann-pt_br</artifactId>
 7            <version>4.0.0</version>
 8        </dependency>
 9    </dependencies>
10    ...
11</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

Exemplo simples

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:

1ComponentFactory factory = ComponentFactory.create(new Locale("pt", "BR"));
2Analyzer cogroo = factory.createPipe();

Crie um objeto do tipo Document e inclua o texto que será processado:

1Document document = new DocumentImpl();
2document.setText(documentText);

O documento será anotado com o comando:

1cogroo.analyze(document);

Usando os getters do documento é possível obter as anotações:

 1for (Sentence sentence : document.getSentences()) { // lista de sentenças
 2  sentence.getStart(); sentence.getEnd(); // caracteres onde a sentença começa e termina
 3  sentence.getText(); // texto da sentença
 4
 5  // Tokens
 6  for (Token token : sentence.getTokens()) { // lista de tokens
 7    token.getStart(); token.getEnd(); // caracteres onde o token começa e termina
 8    token.getLexeme(); // o texto do token
 9    token.getLemmas(); // um array com os possíveis lemas para o par lexeme+postag
10    token.getPOSTag(); // classe morfológica de acordo com o contexto
11    token.getFeatures(); // gênero, número, tempo etc
12  }
13
14  // Chunks
15  for (Chunk chunk : sentence.getChunks()) { // lista de chunks
16    chunk.getStart(); chunk.getEnd(); // índice do token onde o chunk começa e do token onde ele termina
17    chunk.getTag(); // the chunk tag
18    chunk.getTokens(); // a list with the covered tokens
19  }
20
21  // Structure
22  for (SyntacticChunk structure : sentence.getSyntacticChunks()) { // lista de SyntacticChunks
23    structure.getStart(); structure.getEnd(); // índice do token onde o structure começa e do token onde ele termina
24    structure.getTag(); // the structure tag
25    structure.getTokens(); // a list with the covered tokens
26  }
27
28}

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.

Exemplos completos:

O arquivo anexado é um projeto exemplo que usa a API. Após descompactar, faça um build e execute com os comandos:

1mvn install
2mvn exec:java -Dexec.mainClass="org.cogroo.examples.Example" 

src/main/java/org/cogroo/examples/Example.java

  1package org.cogroo.examples;
  2
  3import java.util.Arrays;
  4import java.util.Locale;
  5import java.util.Scanner;
  6
  7import org.cogroo.analyzer.Analyzer;
  8import org.cogroo.analyzer.ComponentFactory;
  9import org.cogroo.text.Chunk;
 10import org.cogroo.text.Document;
 11import org.cogroo.text.Sentence;
 12import org.cogroo.text.SyntacticChunk;
 13import org.cogroo.text.Token;
 14import org.cogroo.text.impl.DocumentImpl;
 15
 16/**
 17 * CoGrOO 4.0.0-SNAPSHOT usage example
 18 */
 19public class Example {
 20
 21  /** the CoGrOO pipe instance */
 22  private Analyzer cogroo;
 23
 24  public Example() {
 25    /*
 26     * The following command creates a component factory given a locale. The
 27     * locale will be resolved as a configuration file in the classpath with the
 28     * following pattern: /models_lang_COUNTRY. Another option is to use the
 29     * method ComponentFactory.create(InputStream) directly.
 30     */
 31    ComponentFactory factory = ComponentFactory.create(new Locale("pt", "BR"));
 32
 33    /*
 34     * Create the default pipe, which is complete, including from sentence
 35     * detection to featurization.
 36     */
 37    cogroo = factory.createPipe();
 38  }
 39
 40  /**
 41   * Creates a document and set the imput text. Finally analyze it using the
 42   * pipe
 43   */
 44  public void analyzeAndPrintDocument(String documentText) {
 45
 46    // Create a document and set the text.
 47    Document document = new DocumentImpl();
 48    document.setText(documentText);
 49
 50    // lets measure the time...
 51    long start = System.nanoTime();
 52
 53    // analyze it
 54    cogroo.analyze(document);
 55
 56    System.out.println("Document processed in " 
 57        + ((System.nanoTime() - start) / 1000000) + "ms");
 58
 59    print(document);
 60  }
 61
 62  /** A utility method that prints the analyzed document to the std output. */
 63  private void print(Document document) {
 64    StringBuilder output = new StringBuilder();
 65
 66    // and now we navigate the document to print its data
 67    for (Sentence sentence : document.getSentences()) {
 68
 69      // Print the sentence. You can also get the sentence span annotation.
 70      output.append("Sentence: ").append(sentence.getText()).append("\n");
 71
 72      output.append("  Tokens: \n");
 73
 74      // for each token found...
 75      for (Token token : sentence.getTokens()) {
 76        String lexeme = token.getLexeme();
 77        String lemmas = Arrays.toString(token.getLemmas());
 78        String pos = token.getPOSTag();
 79        String feat = token.getFeatures();
 80
 81        output.append(String.format("    %-10s %-12s %-6s %-10s\n", lexeme,
 82            lemmas, pos, feat));
 83      }
 84
 85      // we can also print the chunks, but printing it is not that easy!
 86      output.append("  Chunks: ");
 87      for (Chunk chunk : sentence.getChunks()) {
 88        output.append("[").append(chunk.getTag()).append(": ");
 89        for (Token innerToken : chunk.getTokens()) {
 90          output.append(innerToken.getLexeme()).append(" ");
 91        }
 92        output.append("] ");
 93      }
 94      output.append("\n");
 95
 96      // we can also print the shallow parsing results!
 97      output.append("  Shallow Structure: ");
 98      for (SyntacticChunk structure : sentence.getSyntacticChunks()) {
 99        output.append("[").append(structure.getTag()).append(": ");
100        for (Token innerToken : structure.getTokens()) {
101          output.append(innerToken.getLexeme()).append(" ");
102        }
103        output.append("] ");
104      }
105      output.append("\n");
106    }
107
108    System.out.println(output.toString());
109  }
110
111  /**
112   * @param args
113   */
114  public static void main(String[] args) {
115
116    Example ex = new Example();
117
118    Scanner kb = new Scanner(System.in);
119    System.out.print("Enter the sentence or 'q' to quit: ");
120    String input = kb.nextLine();
121
122    while (!input.equals("q")) {
123      ex.analyzeAndPrintDocument(input);
124
125      System.out.print("Enter the sentence or 'q' to quit: ");
126      input = kb.nextLine();
127    }
128  }
129}

src/main/resources/models_pt_BR.xml (do projeto cogroo-base)

 1<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 2<languageConfiguration xmlns:jxb="http://java.sun.com/xml/ns/jaxb" 
 3    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 4    xsi:noNamespaceSchemaLocation="languageConfiguration.xsd">
 5    <locale>pt_BR</locale>
 6    <model type="sentenceDetector">/models/pt-sent.model</model>
 7    <model type="tokenizer">/models/pt-tok.model</model>
 8    <model type="nameFinder">/models/pt-prop.model</model>
 9    <model type="contractionFinder">/models/pt-con.model</model>
10    <model type="posTagger">/models/pt-pos.model</model>
11    <model type="featurizer">/models/pt-feat.model</model>
12    <model type="chunker">/models/pt-chunk.model</model>
13    <model type="headFinder">/models/pt-hf.model</model>
14    <model type="shallowParser">/models/pt-sp.model</model>
15
16    <pipe>
17        <analyzer>sentenceDetector</analyzer>
18        <analyzer>tokenizer</analyzer>
19        <analyzer>nameFinder</analyzer>
20        <analyzer>contractionFinder</analyzer>
21        <analyzer>posTagger</analyzer>
22        <analyzer>featurizer</analyzer>
23        <analyzer>lemmatizer</analyzer>
24        <analyzer>chunker</analyzer>
25        <analyzer>headFinder</analyzer>
26        <analyzer>shallowParser</analyzer>
27    </pipe>
28</languageConfiguration>

Personalizando

Existem diversas maneiras de personalizar o CoGrOO. Sugestões:

Crie um novo models.xml

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:

 1<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 2<languageConfiguration xmlns:jxb="http://java.sun.com/xml/ns/jaxb" 
 3    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 4    xsi:noNamespaceSchemaLocation="languageConfiguration.xsd">
 5    <locale>pt_BR</locale>
 6    <model type="sentenceDetector">/models/pt-sent.model</model>
 7    <model type="tokenizer">/models/pt-tok.model</model>
 8    <model type="nameFinder">/models/pt-prop.model</model>
 9    <model type="contractionFinder">/models/pt-con.model</model>
10    <model type="posTagger">/custom_models/pt-pos.model</model>
11    <model type="featurizer">/models/pt-feat.model</model>
12
13    <pipe>
14        <analyzer>sentenceDetector</analyzer>
15        <analyzer>tokenizer</analyzer>
16        <analyzer>nameFinder</analyzer>
17        <analyzer>contractionFinder</analyzer>
18        <analyzer>posTagger</analyzer>
19        <analyzer>lemmatizer</analyzer>
20    </pipe>
21</languageConfiguration>

Crie um InputStream com o XML e use para criar um ComponentFactory:

1InputStream in = new FileInputStream("models.xml");
2ComponentFactory factory = ComponentFactory.create(in);
3in.close();
4Analyzer 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:

1mvn exec:java -Dexec.mainClass="org.cogroo.examples.ExampleCustomPipe" 

Corretor Gramatical

Para usar a API do corretor gramatical você precisa da seguinte configuração no seu projeto Maven. O elemento <repositories> é necessário apenas se estiver usando uma versão SNAPSHOT.

 1<project>
 2    ...
 3    <dependencies>
 4        <dependency>
 5            <groupId>org.cogroo.lang.pt_br</groupId>
 6            <artifactId>cogroo-gc-pt_br</artifactId>
 7            <version>4.0.0</version>
 8        </dependency>
 9    </dependencies>
10    ...
11</project>

Para inicializar o corretor gramatical crie um Pipe padrão para o idioma e insira nesse pipe um objeto GrammarCheckerAnalyzer:

1// inicializamos os analisadores
2ComponentFactory factory = ComponentFactory.create(new Locale("pt", "BR"));
3
4// criamos o GrammarChecker 
5GrammarChecker gc = new GrammarChecker(pipe);

Para verificar um documento:

1// crie um CheckDocument com o texto:
2CheckDocument document = new CheckDocument("Fomos levados à crer. As bonecas são bonita.");
3// passe o doc pelo pipe
4gc.analyze(document);
5
6// obtenha os resultados em document.getMistakes(), ou simplesmente imprima o documento
7System.out.println(document);

example-0.0.2-SNAPSHOT-project.zip (7 kB) William Colen, 07/11/2012 06:13 pm