|
|
É importante destacar que SimpleNLG-gl é unha libraría [1], non unha aplicación. Isto quere dicir que non se pode executar como un programa Java xa que non ten un método ou módulo principal. É preciso crear un programa Java que empregue as súas clases e os seus métodos.
|
|
|
Para utilizar a libraría SimpleNLG-gl é necesario:
|
|
|
* Descargar o arquivo .zip de SimpleNLG-gl.
|
|
|
* Extraer e engadir o arquivo .jar de SimpleNLG-gl ao classpath.
|
|
|
* Crear unha clase Java que conteña o método “main”. Neste exemplo, imos chamar á clase “TestMain”.
|
|
|
* Na parte superior da clase engadimos os seguintes “import”:
|
|
|
import simplenlg.framework.*;
|
|
|
import simplenlg.lexicon.*;
|
|
|
import simplenlg.lexicon.galician.XMLLexicon;
|
|
|
import simplenlg.realiser.galician.*;
|
|
|
import simplenlg.phrasespec.*;
|
|
|
import simplenlg.features.*;
|
|
|
|
|
|
* Crear un lexicon, NLGFactory e realiser:
|
|
|
|
|
|
Lexicon lexicon = new XMLLexicon();
|
|
|
NLGFactory nlgFactory = new NLGFactory(lexicon);
|
|
|
Realiser realiser = new Realiser(lexicon);
|
|
|
|
|
|
Seguindo estes pasos, deberíase obter un código similar ao seguinte:
|
|
|
import simplenlg.framework.*;
|
|
|
import simplenlg.lexicon.*;
|
|
|
import simplenlg.lexicon.galician.XMLLexicon;
|
|
|
import simplenlg.realiser.galician.*;
|
|
|
import simplenlg.phrasespec.*;
|
|
|
import simplenlg.features.*;
|
|
|
|
|
|
|
|
|
public class TestMain {
|
|
|
|
|
|
public static void main(String[] args) {
|
|
|
Lexicon lexicon = new XMLLexicon();
|
|
|
NLGFactory nlgFactory = new NLGFactory(lexicon);
|
|
|
Realiser realiser = new Realiser(lexicon);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
**Figura 1**: Clase Java lista para utilizar a libraría SimpleNLG-gl
|
|
|
|
|
|
Neste momento xa se pode utilizar a libraría para xerar oracións.
|
|
|
Hai máis exemplos de uso da libraría dispoñibles revisando os arquivos .java na carpeta `test`.
|
|
|
|
|
|
## Xerar o tipo de frase máis simple en SimpleNLG-gl
|
|
|
Imos crear o tipo máis simple de frase que permite SimpleNLG-gl: texto enlatado, isto é, unha cadea que queremos que se mostre tal e como se introduce. Por exemplo, se escribimos un programa que toma a entrada dos usuarios e xera un parágrafo distinto dependendo das entrada pero no que a primeira liña sempre é igual (por exemplo: “O meu can é feliz.”). O código necesario é o seguinte:
|
|
|
NLGElement s1 = nlgFactory.createSentence("o meu can é feliz");
|
|
|
|
|
|
Agora necesitamos utilizar o Realiser para xerar a saída da cadea:
|
|
|
String output = realiser.realiseSentence(s1);
|
|
|
System.out.println(output);
|
|
|
|
|
|
É importante saber que unicamente é preciso crear o `Lexicon`,` NLGFactory` e `Realiser` unha única vez dentro do programa; non é necesario crealos para cada frase que se queira xerar. Polo tanto, unha boa idea é crealos ao inicio do programa e utilizalos durante a súa execución. De feito, si o lexicón empregado contén un elevado número de elementos, cargalo cada vez que se xere unha frase pode aumentar notablemente o tempo de execución da realización lingüística.
|
|
|
|
|
|
## Pasos necesarios para xera una oración más complexa
|
|
|
|
|
|
O exemplo anterior é a forma máis sinxela de crear unha oración. Neste apartado veremos como utilizar SimpleNLG-gl para realizar a maioría do traballo. É importante recordar que é bastante flexible e hai varias formas de xerar oracións.
|
|
|
No nivel máis baixo, SimpleNLG-gl entende que unha oración está utilizando una clase denominada `SPhraseSpec`, accesible mediante `NLGFactory` empregando o método `createClause`. Aos conceptos de 'frase verbal', 'frase nominal', 'frase preposicional', 'frase adxectiva’ e 'frase adverbial' tamén se pode acceder a través de `NLGFactory`, usando ` createVerbPhrase`, `createNounPhrase`,` createPrepositionPhrase` , etc. Estes métodos devolven clases con nomes similares - `VPPhraseSpec`,` NPPhraseSpec`, `PPPhraseSpec`,` AdjPhraseSpec` e `AdvPhraseSpec`.
|
|
|
|
|
|
Para construír unha oración utilizando as clases de SimpleNLG-gl, normalmente hai que seguir estes pasos (explicados de forma máis detallada nas Seccións V e seguintes):
|
|
|
|
|
|
* Crear unha instancia de NLGFactory.
|
|
|
* Crear a oración empregando o método createClause de NLGFactory. Este método devolve unha instancia de SPhraseSpec.
|
|
|
* Crear un suxeito, un verbo e un complemento directo usando os métodos createVerbPhrase e createNounPhrase de NLGFactory. (Estes métodos devolven instancias de VPPhraseSpec e NPPhraseSpec).
|
|
|
* Opcionalmente, crear frases preposicionais, frases adxectivas e adverbios empregando os métodos createPrepositionPhrase, createAdjectivePhrase e createAdverbPhrase de NLGFactory. (Estes métodos devolven instancias PPPhraseSpec, AdjPhraseSpec e AdvPhraseSpec).
|
|
|
* Indicar o papel que as partes do discurso desempeñarán na frase. Por exemplo, especificar que unha frase substantiva é o suxeito da oración e outra frase nominal é o complemento directo, utilizando setSubject e setObject. Especificar o verbo usando setVerb e un complemento (por exemplo, unha frase preposicional) empregando addComplement.
|
|
|
* Crear un obxecto SimpleNLG denominado Realiser.
|
|
|
* Pedir ao Realiser que transforme a instancia de SPhraseSpec nunha cadea sintacticamente correcta.
|
|
|
|
|
|
Finalmente obtense unha cadea de texto que é unha frase ou oración e que se pode tratar como calquera outra cadea de texto de Java.
|
|
|
Hai que ter en conta que este é o enfoque máis detallado xa que se pode utilizar `setSubject`, ` setVerb`, etc., pasando a estes métodos cadeas de texto simples como argumentos. A non ser que se queiran xerar estruturas máis complexas, non é preciso especificar que un suxeito é un `NPPhraseSpec` ou que un verbo é un` VPPhraseSpec`. Consultar a Sección V para ver un exemplo de código Java real utilizado para xerar unha oración.
|
|
|
|
|
|
A continuación móstrase unha táboa coas principais partes do discurso que pode xerar SimpleNLG-gl.
|
|
|
|Parte o discurso|Tipo de frase|Exemplos|Método|
|
|
|
|------------------|-------------|--------|------|
|
|
|
|Suxeito|Frase nominal|"o neno"|setSubject()|
|
|
|
|Verbo|Frase verbal|"deu"|setVerb()|
|
|
|
|Complemento directo|Frase nominal|"un regalo"|setObject()|
|
|
|
|Complemento indirecto|Frase preposicional|"ao can"|setIndirectObject()|
|
|
|
|Complementos|Frase preposicional|"no parque"|addComplement()|
|
|
|
| |Cláusula "que"|"que Sara ve a Xoan"||
|
|
|
| |Frase adxectiva|"encantado de coñecerte"||
|
|
|
| |Frase adverbial|"moi rápido"||
|
|
|
|Modificadores|Cláusula "que"|"a rapaza que coñecía"|addModifier()|
|
|
|
| |Frase adxectiva|"bonita"||
|
|
|
| |Frase adverbial|"rapidamente"||
|
|
|
**Táboa 1**: As partes do discurso que SimpleNLG-gl pode empregar. Los modificadores e artigos engádense a outras frases, o resto e compoñentes engádense a unha oración.
|
|
|
---
|
|
|
|
|
|
[1] Unha libraría ou API é unha colección de métodos/funcións que se poden utilizar en outros programas. Isto evita que os programadores teñan que escribir ese código. |