Apertium Nieuw talenpaar HOWTO

Apertium Nieuw talenpaar HOWTO
Dit HOWTO document zal beschrijven hoe je vanaf het begin een nieuw talenpaar moet starten voor het Apertium computervertalingssysteem.
Het is niet nodig om iets van de taal of van het vertalingssysteem te kennen, maar het is wel belangrijk dat je het onderscheid tussen een naamwoord,adjectief... kan maken.

Inleiding

Apertium is, zoals je waarschijnlijk al had begrepen, een automatisch computervertalingssysteem. Dit klopt niet helemaal, het is een computervertalingsplatform. Apertium voorziet een "motor" en "gereedschap" zodat je zelf je eigen computervertalingssystemen kan maken. Het enige wat je zelf moet doen, is de data schrijven. De data bestaat uit 3 belangrijke delen, de woordenboeken, en enkele regels (woordvolgorde en andere grammatica).
Als je meer info wilt over het Apertiumproject kan je hier eens kijken: http://wiki.apertium.org/wiki/Publications

Programma's

Om apertium te laten werken heb je de volgende programma's nodig:

• lttoolbox(>= 3.0.0)
  
• libxml utils (xmllint etc.)
  
• apertium (>= 3.0.0)
  
• Tekstverwerker (of een XML-verwerker)
  

Dit document legt niet uit hoe je deze programma's moet installeren. Als je meer info nodig hebt, kijk dan op de Apertium-site.

Waaruit bestaat een talenpaar?

Apertium is een oppervlakkig computervertalingssysteem. Dit is omdat het enkel via woordenboeken en enkele oppervlakkige regels kan vertalen. Het verschil met grondige vertalingen is dat Apertium niet aan syntactische zinsontleding kan doen. De regels die Apertium gebruikt zijn gebaseerd op typische overeenkomsten in lexicale groepen, eerder dan "de bewerkingen op de parsetree". Op het basisniveau zijn er 3 belangrijke woordenboeken:

1. Het morfologisch woordenboek voor taal xx: dit bevat de regels over hoe woorden in taal xx zijn verbogen. In ons voorbeeld wordt het zo genoemd: apertium-sh-en.sh.dix
2. Het morfologisch woordenboek voor taal yy: dit bevat de regels over hoe woorden in taal yy zijn verbogen. In ons voorbeeld wordt het zo genoemd: apertium-sh-en.en.dix
3. Een tweetalig woordenboek: dit bevat overeenkomsten tussen woorden en symbolen van de 2 talen. In ons voorbeeld wordt het zo genoemd: apertium-sh-en.sh-en.dix

In een talenpaar kunnen beide talen de bron of de bestemming zijn. Deze termen zijn relatief.

Er bestaan ook 2 bestanden van vertalingsregels. Dit zijn de regels die bepalen hoe woorden herordend worden in zinnen bv. chat noir --> kat zwart --> zwarte kat. Het bepaalt ook de geslachtsaanpassingen, getallen etc. Deze regels kunnen ook gebruikt worden om nieuwe lexicale items toe te voegen of te verwijderen. Deze bestanden zijn:

1. vertalingsregels van taal xx naar taal yy: dit bestand bevat de regels van hoe taal xx in taal yy wordt veranderd. In ons voorbeeld wordt het zo genoemd: apertium-sh-en.sh-en.t1x
2. ertalingsregels van taal yy naar taal xx: dit bestand bevat de regels van hoe taal yy in taal xx wordt veranderd. In ons voorbeeld wordt het zo genoemd: apertium-sh-en.en-sh.t1x

Veel van de talenparen hebben ook nog andere bestanden, maar die komen hier niet aan bod. Die bestanden zijn enkel nodig om het systeem te laten werken.

Talenpaar

Zoals je misschien al hebt gezien aan de bestandsnamen, gebruikt deze handleiding het voorbeeld Servo-Kroatisch en Engels om te tonen hoe je een basissyteem moet maken.
Dit is geen ideaal paar omdat het systeem beter werkt voor talen die meer verbanden met elkaar hebben. Maar dit zal geen problemen zijn bij de simpele voorbeelden die we hier gebruiken.

Enkele opmerkingen over "TERMS?"

Er zijn enkele termen die je zal moeten begrijpen voor we verdergaan.

De 1e term is lemma. Een lemma is een woord dat niet is aangepast door enige grammatica. Bv. het lemma van katten is kat. Voor Engelse woorden zal dit het enkelvoud van die woorden zijn. Voor werkwoorden zal dit de infinitief zijn zonder "to". Bv. het lemma van "was" wordt dan "be".

De 2e term is symbool. In de context van Apertium verwijst "symbool" naar de grammaticale vorm. Bv. katten is een zelfstandig naamwoord(noun) in het meervoud(plural). Daarom krijgt katten het symbool "noun" en het symbool "plural". Bij de input en output van apertium worden deze meestal tussen "<" en ">" weergeven:

• <n>; voor een "noun".
• <pl>; voor een "plural".

Andere voorbeelden van symbolen zijn <sg>; singular(enkelvoud), <p1>; first person(eerste persoon), <pri>; indicatief, etc. "<" en ">" worden ook wel tags genoemd. In veel van de beschikbare talenparen zijn de betekenissen van de symbolen acroniemen van Catalaanse woorden. Bv. vbhaver ---- van vb (verb).

De 3e term is paradigma. In de context van Apertium verwijst paradigma naar hoe een groep woorden met dezelfde kenmerken wordt verbogen. In het morfologische woordenboek worden lemma's gelinkt aan paradigma's. Zo kunnen wij beschrijven hoe een lemma verbogen wordt zonder alle uitgangen te moeten schrijven.

Een voorbeeld van het nut is dat, als we bv. de 2 adjectieven "happy" en "lazy" zouden opslaan, dat we gelijkaardige verbuigingen in 1 keer in het systeem kunnen steken, zonder dat we alle mogelijkheden moeten schrijven

1. happy, happ (y, ier, iest)
2. lazy, laz (y, ier, iest)

Zo kunnen we simpelweg 1 model opslaan en dan zeggen dat "lazy verbogen wordt zoals happy", of dat "shy verbogen wordt zoals happy", "naughty zoals happy" etc. In dit voorbeeld is "happy" het paradigma en is het het voorbeeld hoe gelijkaardige woorden verbogen moeten worden. Paradigma's worden gedefinieerd in <pardef> tags en gebruikt in <par> tags.

Eentalig woordenboek

Laten we beginnen met ons eerste woordenboek te schrijven. Het woordenboek is een XML bestand. Open je tekstverwerker en typ dit in:

<?xml version="1.0" encoding="UTF-8"?>
<dictionary>

</dictionary>

Het bestand begrijpt dat we een woordenboek willen maken. Voordat het nuttig wordt, moeten we wat meer parameters toevoegen, de eerste is het alfabet. Dit definieert de letters die er worden gebruikt in dat woordenboek, voor Servich-Kroatisch zal het dan alle letters van het Servo-Kroatisch alfabet bevatten:

<alphabet>ABCČĆDDžĐEFGHIJKLLjMNNjOPRSŠTUVZŽabcčćddžđefghijklljmnnjoprsštuvzž</alphabet>

Zet het alfabet juist onder de <dictionary> tag. Daarna moeten we enkele symbolen definiëren. Laten we beginnen met makkelijke voorbeelden, een "noun"(n) in "singular"(sg) en in "plural"(pl).

<sdefs>
   <sdef n="n"/>
   <sdef n="sg"/>
   <sdef n="pl"/>
</sdefs>

De namen van de symbolen moeten niet zo kort zijn, je mag ze ook voluit schrijven, maar omdat je ze heel veel zal moeten typen, is het makkelijk om ze af te korten. Maar dit is niet zo gemakkelijk in het Servo-Kroatisch. Daar verbuig je zelfstandige naamwoorden niet enkel volgens getal(enkelvoud & meervooud), maar ook volgens "case" en hebben een geslacht. Hoe dan ook, we nemen voor dit voorbeeld aan dat het zelfstandig naamwoord mannelijk is in de nominatief (Een volledig voorbeeld vind je op het einde van dit document. Het volgende wat we moeten doen, is het maken van een sectie voor de paradigma's,

<pardefs>

</pardefs>

en een voor de sectie van het woordenboek:

<section id="main" type="standard">

</section>

Er bestaan 2 types secties. Het eerste is de standaardsectie en bevat woorden,clitica, etc. Het 2e type wordt de "voorwaardelijke" type genoemd en en bevat grammaticale elementen zoals punctuatie etc. In dit voorbeeld gebruiken we geen "voorwaardelijke" sectie. Ons bestand zou er nu zo moeten uitzien:

<?xml version="1.0" encoding="UTF-8"?>
<dictionary>
   <sdefs>
     <sdef n="n"/>
     <sdef n="sg"/>
     <sdef n="pl"/>
   </sdefs>
   <pardefs>

   </pardefs>
   <section id="main" type="standard">

   </section>
</dictionary>

Nu dat we onze we onze basis hebben gemaakt, kunnen we er een zelfstandig naamwoord aan toevoegen. In ons voorbeeld zal dat "gramafon" zijn. Het eerste wat me moeten doen is, omdat we nog geen model paradigma's hebben, er een definiëren. Denk eraan, wij gebruiken het mannelijk in de nominatief. Het enkelvoud van dit woord is "gramofon" en het meervoud is "gramofoni". Dus:

<pardef n="gramofon__n">
   <e><p><l/><r><s n="n"/><s n="sg"/></r></p></e>
   <e><p><l>i</l><r><s n="n"/><s n="pl"/></r></p></e>
</pardef>

Merk op: de '<l/>'(is hetzelfde als <l></l>) wil zeggen dat er niets anders toe te voegen is in de secite "sg" voor het woord "gramofon". Op dit moment zal je je waarschijnlijk afvragen waarvoor deze tekens dienen (">" en "<"). Daar zijn bepaalde redenen voor en het gebruik ervan zal je snel oppikken. Je vraag je misschien af wat <e>,<l> en <r> betekenen:

• e, is voor een "entry".
• p, is voor een paar.
• l, is voor links.
• r, is voor rechts.

Waarom links en rechts? Dit is omdat eentalige woordenboeken zullen samengesteld worden tot vervoegde "state machines". Compiling deze van links naar rechts betekent dat deze woorden zullen analyseren, en van rechts naar links betekent dat er woorden zullen gemaakt worden uit analyses. Bijvoorbeeld:

* gramofoni (left to right) gramofon<n><pl> (analysis)
* gramofon<n><pl> (right to left) gramofoni (generation)

Nu dat we een paradigma gedefinieerd hebben, moeten we het aan zijn lemma linken, nl. "gramofon". We plaatsen deze in de sectie die we gedefinieerd hebben. Het commando dat je in de sectie moet steken ziet er zo uit:

<e lm="gramofon"><i>gramofon</i><par n="gramofon__n"/></e>

Nog enkele afkortingen:

1. lm --> lemma
2. i --> identity (links en rechts zijn hetzelfde)
3. par --> paradigma

Deze entry definieert, voor het lemma "gramofon", het paradigma dat verbonden is aan "gramofon_n". Het verschil tussen een lemma en de wortel is dat het lemma de de vorm is zonder grammaticale aanpassingen, terwijl de wortel de substring van de lemma is en waaraan suffixen worden toegevoegd. Dit zal later nog duidelijk worden wanneer een entry laten zien waar de 2 verschillend zijn.
We zijn nu klaar om het woordenboek te testen. Slaag het op, en keer terug naar de shell. We moeten het eerst samenstellen (met It-comp), daarna kunnen we het testen (met It-proc). Voor diegenen die nieuw zijn met cygwin, zorg ervoor dat je het bestand van het woordenboek opslaat in de home folder (bv. C:\Apertium\home\Gebruikersnaam\naam_van_woordenboek) Anders zal je niets kunnen samenstellen.

$ lt-comp lr apertium-sh-en.sh.dix sh-en.automorf.bin

Deze output zou er moeten komen:

main@standard 12 12

Als we het van links naar rechts samenstellen, dan maken we een analysator. Laten we ook nog een generator maken.

$ lt-comp rl apertium-sh-en.sh.dix sh-en.autogen.bin

Op dit punt zou het commando dezelfde output moeten produceren. Dit kunnen we testen. Open It-proc en gebruik het op de analysator.

$ lt-proc sh-en.automorf.bin

Test het nu, typ "gramofoni" en kijk naar de output:

^gramofoni/gramofon<n><pl>$

Doe nu hetzelfde voor het Engelse woordenboek, maar vervang nu het Engelse woord "grampohone" door "gramofon" en verander de verbuiging in het meervoud. Wat als je het meer correcte "record player" wil gebruiken? Dat leggen we later nog uit.
Er zouden nu 2 bestanden in de map moeten staan:

1. apertium-sh-en.sh.dix , dit bevat een (simplistisch) eentalig Servo-Kroatisch woordenboek
2. apertium-sh-en.en.dix, dit bevat een (simplistisch) eentalig Engels woordenboek.

Tweetalig woordenboek

Nu hebben we dus 2 morfologische woordenboeken. Het volgende wat we moeten doen, is een tweetalig woordenboeken maken. Dit woordenboek legt de link tussen woorden van de 2 talen. Alle woordenboeken gebruiken hetzelfde formaat (wat bepaald is in de DTD, dix.dtd)
Open een nieuw bestand; apertium-sh-en.sh-en.dix en voeg het basisskelet toe:

<?xml version="1.0" encoding="UTF-8"?>
<dictionary>
   <alphabet/>
   <sdefs>
     <sdef n="n"/>
     <sdef n="sg"/>
     <sdef n="pl"/>
   </sdefs>

   <section id="main" type="standard">

   </section>
</dictionary>

Nu moeten we een entry ingeven om 2 woorden te laten vertalen:

<e><p><l>gramofon<s n="n"/></l><r>gramophone<s n="n"/></r></p></e>

Omdat er heel veel van deze entries zijn, gebruikt men meestal 1 lijn per entry om het zo leesbaarder te maken. Weeral met 'l' en 'r'? We stellen het "links naar rechts" om het woordenboek "Servo-Kroatisch --> Engels" te maken en "rechts naar links" om het woordenboek "Engels-Servo-Kroatisch" te maken.
Als dit gedaan is, voer dan deze commando's uit:

$ lt-comp lr apertium-sh-en.sh.dix sh-en.automorf.bin
$ lt-comp rl apertium-sh-en.en.dix sh-en.autogen.bin

$ lt-comp lr apertium-sh-en.en.dix en-sh.automorf.bin
$ lt-comp rl apertium-sh-en.sh.dix en-sh.autogen.bin

$ lt-comp lr apertium-sh-en.sh-en.dix sh-en.autobil.bin
$ lt-comp rl apertium-sh-en.sh-en.dix en-sh.autobil.bin

Dit maakt de morfologische analysators(automorf), een morfologische generator (autogen) en een zoekfunctie (autobil)(bil voor "bilingual")

Vertalingsregels

We hebben nu dus 2 morfologische en 1 tweetalig woordenboeken. Alles wat we nu nodig hebben is een vertalingsregel voor zelfstandige naamwoorden. De bestanden van vertalingsregels hebben hun eigen DTD(transfer.dtd), die kan je terugvinden het Apertium packet. Als je een regel wil invoegen, is het optimaal om eerst in andere bestanden naar andere vertalingsregels te kijken en zich daarop te baseren. Veel regels kunnen opnieuw gebruikt worden voor andere talen. Het voorbeeld hieronder kan handig zijn voor elke "null-subject language."
Begin zoals alle anderen met het basisskelet (apertium-sh-en.sh-en.t1x ) :

<?xml version="1.0" encoding="UTF-8"?>
<transfer>

</transfer>

Op dit moment, omdat we naamvallen negeren, hebben we enkel een regel nodig die de ingevoerde grammaticale symbolen (input) verandert in output.
We zullen daarvoor eerst categorieën en attributen moeten definiëren. Categorieën en attributen zorgen ervoor dat we grammaticale symbolen in een groep kunnen zetten. Categorieën zorgen ervoor dat we symbolen,die we gebruiken om woorden die overeenkomen ,in groep kunnen zetten (bv. 'n. *' zijn alle zelfstandige naamwoorden)
Attributen zorgen ervoor dat we een set van symbolen waaruit we kunnen kiezen, kunnen samenzetten. Bv. ('sg' en 'pl' kunnen het attribuut "number" krijgen).
Laten we de nodige secties toevoegen:

<section-def-cats>

</section-def-cats>
<section-def-attrs>

</section-def-attrs>

Omdat we enkel woorden naar het enkelvoud en meervoud verbuigen, moeten we een extra categorie voor zelfstandige naamwoorden maken, en een attribuut van het getal. Zoiets dat hier staat is voldoende: voeg In de sectie "section-def-cats" dit toe:

<def-cat n="nom">
   <cat-item tags="n.*"/>
</def-cat>

Dit vangt alle zelfstandige naamwoorden (lemma's die gevolgd worden door <n>) en verwijst er naar als "nom"(we zien later hoe dat wordt gebruikt).
Voeg in de sectie "section-def-attrs" dit toe:

<def-attr n="nbr">
   <attr-item tags="sg"/>
   <attr-item tags="pl"/>
</def-attr>

en daarna

<def-attr n="a_nom">
   <attr-item tags="n"/>
</def-attr>

Het eerste definieert het attribuut nbr(number). Dit kan enkelvoud(sg) of meervoud(pl) zijn.
Het 2e definieert het attribuut a_nom(attribute noun).
Daarna moeten we een sectie voor globale variabelen toevoegen:

<section-def-vars>

</section-def-vars>

Deze variabelen worden gebruikt om attributen tussen de regels op te slaan of over te dragen. Voorlopig hebben we er 1 nodig.

<def-var n="number"/>

Uiteindelijk moeten we een regel toevoegen om een zelfstandig naamwoord te nemen en het dan in de juiste output te veranderen. Daarvoor hebben we een regel-sectie nodig...

<section-rules>

</section-rules>

Hier is een voorbeeld van zo een regel:

<rule>
   <pattern>
     <pattern-item n="nom"/>
   </pattern>
   <action>
     <out>
       <lu>
         <clip pos="1" side="tl" part="lem"/>
         <clip pos="1" side="tl" part="a_nom"/>
         <clip pos="1" side="tl" part="nbr"/>
       </lu>
     </out>
   </action>
</rule>

De eerste tag is duidelijk, deze definieert een regel. De 2e tag zegt :"pas deze regel toe, als het patroon gevonden is". In dit voorbeeld bestaat het patroon uit 1 zelfstandig naamwoord. Merk op dat de patronen een overeenkomst hebben met de langste resultaten. Als je 3 regels hebt en de 1e komt overeen met "<prn><vblex><n>", de 2e met "<prn><vblex>" en de 3e met "<n>", dat het patroon dat gekozen zal worden, het eerste is. De eerste regel wordt dan uitgevoerd.
Voor elk patroon is er een geassocieerde actie, dat een geassocieerde output oplevert. De output is een lexicale eenheid (lu). De tag "clip" zorgt ervoor dat de gebruiker de attributen, lexicale items van de oorspronkelijke taal(source language='sl')of de doeltaal(target language='tl') kan kiezen en veranderen.
Laten we dit samenstellen en testen. Vertalingsregels worden samengesteld met:

$ apertium-preprocess-transfer apertium-sh-en.sh-en.t1x sh-en.t1x.bin

Dit zal het bestand "sh-en.t1x.bin" maken.
Nu zijn we klaar om ons computervertalingssysteem te testen. Maar er ontbreekt 1 belangrijk deel, de "part-of-speech(PoS)" tag, maar dat wordt direct nog uitgelegd. Ondertussen kunnen we het als volgt testen:
Laten we eerst een woord analysren, gramofoni:

$ echo "gramofoni" | lt-proc sh-en.automorf.bin 
^gramofoni/gramofon<n><pl>$

Normaal zou de PoS tag de juiste versie kiezen, maar dat hebben we nog niet, dus kunnen we enkel dit saaie script (dankzij Sergio) gebruiken. Dit zal gewoon de output geven van het eerste item.

$ echo "gramofoni" | lt-proc sh-en.automorf.bin | \
  gawk 'BEGIN{RS="$"; FS="/";}{nf=split($1,COMPONENTS,"^"); for(i = 1; i<nf; i++) printf COMPONENTS[i]; if($2 != "") printf("^%s$",$2);}'
^gramofon<n><pl>$

Laten we dat nu verwerken met de vertalingsregel:

$ echo "gramofoni" | lt-proc sh-en.automorf.bin | \
  gawk 'BEGIN{RS="$"; FS="/";}{nf=split($1,COMPONENTS,"^"); for(i = 1; i<nf; i++) printf COMPONENTS[i]; if($2 != "") printf("^%s$",$2);}' | \
  apertium-transfer apertium-sh-en.sh-en.t1x sh-en.t1x.bin sh-en.autobil.bin

Dan komt er:

^gramophone<n><pl>$^@

1. 'Gramophone' is de lemma van de doeltaal(side='tl') op positie 1 (pos="1").
2. '<n>' is de doeltaal a_nom op positie 1.
3. '<pl>' is het doeltaalattribuut van het getal(nbr) op positie 1.

Probeer commentaar te geven op een van deze uitspraken, gebruik het programma opnieuw en kijk wat er gebeurt.
Nu hebben we dus de output van de omzetting, het enige wat je nog moet doen is het genereren van verbogen vormen naar de doeltaal. Hiervoor gebruiken we "It-proc", maar in "generation(-g)" en niet "analysis mode".

$ echo "gramofoni" | lt-proc sh-en.automorf.bin | \
  gawk 'BEGIN{RS="$"; FS="/";}{nf=split($1,COMPONENTS,"^"); for(i = 1; i<nf; i++) printf COMPONENTS[i]; if($2 != "") printf("^%s$",$2);}' | \
  apertium-transfer apertium-sh-en.sh-en.t1x sh-en.t1x.bin sh-en.autobil.bin | \
  lt-proc -g sh-en.autogen.bin

gramophones\@

En dat is het. Je hebt nu een computervertalingssysteem dat een Servo-Kroatisch woord in een Engels woord vertaald. Maar dit is niet echt nuttig, maar we zullen snel naar de ingewikkelde spullen gaan. En maak je geen zorgen over het '@' symbool, dat zal ik binnenkort uitleggen.
Denk eens aan andere woorden die op dezelfde manier als 'gramofon' verbogen worden. Wat als je deze eens toevoegt? We moeten geen nieuwe paradigma's toevoegen, maar enkel de entries in de belangrijkste sectie van de eentalige en tweetalige woordenboeken.