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("
");
71
72 output.append(" Tokens:
");
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
", 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("
");
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("
");
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);