Nieuw talenpaar maken

From Apertium
Jump to: navigation, search

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 zelfstandig naamwoord,adjectief etc. kan maken.

Contents

[edit] 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 eens naar de publicationspagina kijken.

[edit] 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.

[edit] 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. vertalingsregels 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.

[edit] 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.

[edit] Een kort stukje terminologie

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) en haver (Catalaans voor "hebben").


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.

[edit] Beginnen

[edit] 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 eindigetoestandsautomaten. Deze van links naar rechts compileren betekent dat deze woorden geanalyseerd zullen worden, en van rechts naar links betekent dat er woorden zullen gemaakt worden uit analyses. Bijvoorbeeld:

* gramofoni (van links naar rechts) gramofon<n><pl> (analyse)
* gramofon<n><pl> (van rechts naar links) gramofoni (genereren)

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 stam is dat het lemma de vorm is zonder grammaticale aanpassingen, terwijl de stam 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.

[edit] 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")

[edit] Vertalingsregels

We hebben nu dus 2 morfologische woordenboeken en 1 tweetalig woordenboek. 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 taal die geen onderwerp gebruikt.
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.

[edit] Laat die werkwoorden maar komen

Ok, nu hebben we een systeem dat zelfstandige naamwoorden kan vertalen, maar dit is redelijk nutteloos. Wij willen ook werkwoorden kunnen vertalen en zelfs hele zinnen! Laten we beginnen met het werkwoord "see"(zien). In het Servo-Kroatisch is dit videti. Servo-Kroatisch is een taal die geen onderwerp gebruikt, dit wil zeggen dat ze geen persoonlijke voornaamwoorden gebruiken voor de vervoegde vorm van het werkwoord. In het Engels is dit niet zo. Bv. "I see" in het Engels zal dan als "vidim" vertaald worden in het Servo-Kroatisch.

  • Vidim
  • see<p1><sg>
  • I see

Opmerking: <p1> betekent 1e persoon
Dit zal belangrijk zijn wanneer we vertalingsregels voor werkwoorden hebben. Andere voorbeelden van talen zonder onderwerpen zijn Spaans, Roemeens en Pools. Dit zorgt ervoor dat we in het Servo-Kroatisch enkel het werkwoord in het morfologisch woordenboek moeten steken, terwijl we in het Engels het werkwoord en de persoonlijke voornaamwoorden moeten toevoegen.
De andere vormen van het werkwoord zien in het Servo-Kroatisch zijn "vidiš, vidi, vidimo, vidite, en vide"; deze komen overeen met "you see (singular), he sees, we see, you see (plural) en they see".
Er bestaan 2 vormen van 'you see', een is meervoud en formeel enkelvoud(vidite) en de andere is enkelvoud en informeel(vidis)
Wij gaan de de zin "vidim gramofono" proberen te vertalen in "I see gramophones". Om meer ruimte te maken, moeten we genoeg informatie geven om te vertalen en zullen we de paradigma's weglaten(de andere vervoegingen van het werkwoord) als oefening voor de lezer.
De opmerkzame lezer zal op dit punt wel al gemerkt hebben dat we "vidim gramofoni" niet kunnen vertalen omdat het grammaticaal geen correcte zin is in het Servo-Kroatisch. De correcte vorm is "vidim gramofone", omdat het zelfstandig naamwoord hier in de accusatief staat. Die vorm zullen we ook moeten toevoegen, maar voorlopig is het toevoegen van een naamval niet nodig, we zullen die vorm als een andere meervoudsvorm toevoegen. Kopieer in de definitie van het paradigma het 'e' block voor 'i' en verander daar de 'i' door 'e'.

<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>
   <e><p><l>e</l><r><s n="n"/><s n="pl"/></r></p></e>
</pardef>

Het eerste wat we moeten doen is wat meer symbolen toevoegen. Eerst moeten een symbool voor 'verb' toevoegen, dit zullen we "vblex" noemen(dit betekent lexicaal werkwoord, dit is niet hetzelfde als een hulpwerkwoord of andere soorten). Werkwoorden hebben een 'persoon', een 'tijd' (samen met een getal); laten we die ook maar toevoegen. We moeten "I see" vertalen, dus de persoon die we moeten toevoegen is "p1" (first person) en als tijd "pri" (tegenwoordige tijd).

<sdef n="vblex"/>
<sdef n="p1"/>
<sdef n="pri"/>

Wanneer we dit gedaan hebben, (hetzelfde als bij de zelfstandige naamwoorden) voegen we een paradigma voor de vervoeging van het werkwoord toe. De eerste regel zal dit zijn:

<pardef n="vid/eti__vblex">

De "/" is er om aan te duiden waar het systeem moet stoppen waar de stamvormen (de delen tussen de <l> en </l> tags) zijn toegevoegd.
De verbuiging voor de eerste persoon enkelvoud:

Then the inflection for first person singular:


<e><p><l>im</l><r>eti<s n="vblex"/><s n="pri"/><s n="p1"/><s n="sg"/></r></p></e>

De 'im' wijst op de uitgang (im van vidim). Het is noodzakelijk om 'eti' in de <r> sectie te plaatsen, omdat deze eraf zal worden gehakt door de definitie. De rest is rechtaan, 'vblex' is een typisch lexicaal werkwoord, 'pri' betekent 'present indicative', 'p1' is de eerste persoon en 'sg' is enkelvoud. We kunnen ook het meervoud toevoegen, wat hetzelfde zal zijn, behalve 'imo' in plaats van 'im' en 'pl' in plaats van 'sg'
Hierna zullen we een lemma en een paradigma moeten toevoegen die gelinkt zijn aan de belangrijkste section:

<e lm="videti"><i>vid</i><par n="vid/eti__vblex"/></e>

Merk op: de inhoud van is de stam, niet het lemma.
Dat is al het werk voor het Servo-Kroatisch woordenboek voor nu. Laten we dit werk samenzetten en dan testen.

$ lt-comp lr apertium-sh-en.sh.dix sh-en.automorf.bin
main@standard 23 25
$ echo "vidim" | lt-proc sh-en.automorf.bin
^vidim/videti<vblex><pri><p1><sg>$
$ echo "vidimo" | lt-proc sh-en.automorf.bin
^vidimo/videti<vblex><pri><p1><pl>$

Ok, nu moeten we hetzelfde voor het Engelse woordenboek doen(denk eraan om dezelfde definities aan de symbolen te geven als bij het Servo-Kroatisch). Dit paradigma is:

<pardef n="s/ee__vblex">

Omdat de verleden tijd 'was' is. Nu kunnen we 2 verschillende dingen doen, we kunnen eerst 1e en 2e persoon toevoegen, maar die hebben dezelfde vorm. Meer zelfs, alle vormen(behalve 3e persoon enkelvoud) van het werkwoord 'to see' zijn 'see'. We maken dus 1 entry voor 'see' en geven het het symbool 'pri'.


<e><p><l>ee</l><r>ee<s n="vblex"/><s n="pri"/></r></p></e>

En zoals altijd, een entry in de belangrijkste sectie:

<e lm="see"><i>s</i><par n="s/ee__vblex"/></e>

Slaag dan op, plaats het opnieuw samen en test het:

$ lt-comp lr apertium-sh-en.en.dix en-sh.automorf.bin
main@standard 18 19

$ echo "see" | lt-proc en-sh.automorf.bin
^see/see<vblex><pri>$

Nu komt de verplichte entry voor het tweetalig woordenboek:

<e><p><l>videti<s n="vblex"/></l><r>see<s n="vblex"/></r></p></e>

(Vergeet niet om de 'sdefs' van eerder toe te voegen.
Zet het opnieuw samen:

$ lt-comp lr apertium-sh-en.sh-en.dix sh-en.autobil.bin
main@standard 18 18
$ lt-comp rl apertium-sh-en.sh-en.dix en-sh.autobil.bin
main@standard 18 18

Nu testen:

$ echo "vidim" | 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

^see<vblex><pri><p1><sg>$^@

We krijgen nu de correcte analyse, maar wanneer we een oppervlakte vorm proberen te genereren, krijgen we een '#' zoals hieronder:

$ echo "vidim" | 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
#see\@

De '#' betekent dat de generator de correcte lexicale vorm niet kan weergeven omdat het dit niet bevat. Waarom is dit?
De analyses komen niet overeen, de 'see' in het woordenboek is 'see<vblex><pri>', maar de 'see' die overgeleverd wordt is see<vblex><pri><p1><sg>. Het Servo-Kroatisch bevat meer informatie dan het Engels nodig heeft. Je kan dit testen door de ontbrekende symbolen aan het Engelse woordenboek toe te voegen, dan opnieuw samen te plaatsen, en dan terug te testen.
Hoe dan ook, een meer pragmatische manier om hier mee om te gaan is een nieuwe regel schrijven. We openen dus het regelbestand (apertium-sh-en.sh-en.t1x sh-en.t1x.bin sh-en.autobil.bin voor het geval dat je het was vergeten)
We moeten nu een nieuwe categorie voor 'verb' (werkwoord) toevoegen.

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

We moeten ook nieuwe attributen toevoegen voor de tijd en de persoon. We zullen het nu heel makkelijk maken, je kan 'p2' en 'p3' toevoegen, maar ik ga het niet doen om plaats te sparen.

<def-attr n="temps">
   <attr-item tags="pri"/>
</def-attr>

<def-attr n="pers">
   <attr-item tags="p1"/>
</def-attr>

We moeten ook een attribuut voor werkwoorden toevoegen.

<def-attr n="a_verb">
   <attr-item tags="vblex"/>
</def-attr>

Nu in de regel:

<rule>
   <pattern>
     <pattern-item n="vrb"/>
   </pattern>
   <action>
     <out>
       <lu>
         <clip pos="1" side="tl" part="lem"/>
         <clip pos="1" side="tl" part="a_verb"/>
         <clip pos="1" side="tl" part="temps"/>
       </lu>
     </out>
   </action>
</rule>

Denk aan wanneer je commentaar probeerde te geven voor de 'clip' tags in een andere regel van het vorige voorbeeld en dat ze verdwenen van de overlevering, dat is eigenlijk wat we nu aan het doen zijn. We nemen een werkwoord met een volledige analyse, maar er enkel een gedeeltelijke analyse gaan krijgen(=output). Die gedeeltelijke analyse bestaat uit een 'lemma', een 'verb tag' en een 'tense tag'.
Als we dit even opnieuw samenplaatsen krijgen we:

$ echo "vidim" | 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
^see<vblex><pri>$^@

en:

$ echo "vidim" | 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
see\@

Probeer het nu met 'vidimo'(wij zien) en kijk of je de juiste output krijgt.
Probeer nu eens met "vidim gramofone":

$ echo "vidim 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
see gramophones\@

[edit] Persoonlijke voornaamwoorden

Dat is fantastisch, maar we missen de nodige persoonlijke voornaamwoorden in het Engels nog. Voor we deze kunnen toevoegen, moeten we eerst het Engelse morfologische woordenboek aanpassen.
Zoals eerder is het eerste wat we moeten doen de nodige symbolen toevoegen:

<sdef n="prn"/>
<sdef n="subj"/>

Prn is het symbool voor 'pronoun' en subj is 'subject'(onderwerp, als in het onderwerp van een zin).
Omdat er geen stam of lemma is voor persoonlijke voornaamwoorden voegen we gewoon het pardef toe:

<pardef n="prsubj__prn">
   <e><p><l>I</l><r>prpers<s n="prn"/><s n="subj"/><s n="p1"/><s n="sg"/></r></p></e>
</pardef>

'Prsubj' betekent 'personal subject'. De anderen (you,we etc.) worden opengelaten als oefening voor de lezer.
We kunnen een entry in de hoofdsectie toevoegen als volgt:

<e lm="personal subject pronouns"><i/><par n="prsubj__prn"/></e>

Slaag op, zet alles samen en test. We zouden nu zoiets als dit moeten krijgen:

$ echo "I" | lt-proc en-sh.automorf.bin
^I/PRPERS<prn><subj><p1><sg>$

(Opmerking: het staat in hoofdletters omdat 'l' een hoofdletter is)
Nu moeten we de 'verb' regel verbeteren om het subject personal pronoun samen met de juiste vorm te krijgen.
Laten we eerst een categorie toevoegen(dit zou een gewoonte moeten worden):

<def-cat n="prpers">
   <cat-item lemma="prpers" tags="prn.*"/>
</def-cat>

Voeg nu de types voornaamwoorden toe als attribuut, we kunnen het 'obj' type ook al toevoegen nu we er toch mee bezig zijn, maar we hebben het nu nog niet nodig:

<def-cat n="prpers">
   <cat-item lemma="prpers" tags="prn.*"/>
</def-cat>

Now add the types of pronoun as attributes, we might as well add the 'obj' type as we're at it, although we won't need to use it for now:

<def-attr n="tipus_prn">
   <attr-item tags="prn.subj"/>
   <attr-item tags="prn.obj"/>
</def-attr>

Voeg nu deze regel in:

<rule>
   <pattern>
     <pattern-item n="vrb"/>
   </pattern>
   <action>
     <out>
       <lu>
         <lit v="prpers"/>
         <lit-tag v="prn"/>
         <lit-tag v="subj"/>
         <clip pos="1" side="tl" part="pers"/>
         <clip pos="1" side="tl" part="nbr"/>
       </lu>
       <b/>
       <lu>
         <clip pos="1" side="tl" part="lem"/>
         <clip pos="1" side="tl" part="a_verb"/>
         <clip pos="1" side="tl" part="temps"/>
       </lu>
     </out>
   </action>
</rule>

Dit is ongeveer dezelfde regel als eerder, maar nu hebben we enkele kleine veranderingen gemaakt. We moesten dit verkrijgen:

^prpers<prn><subj><p1><sg>$ ^see<vblex><pri>$

zodat de generator kon kiezen tussen het juiste voornaamwoord en de juiste vorm van het werkwoord.
Kort:

  1. <lit>, dit plakt een letterlijke regel, in dit geval "prpers"
  2. <lit-tag>, dit plakt een letterlijke tag, omdat we de tags van het werkwoord niet kunnen krijgen, voegen we ze zelf toe, "prn" voor "pronoun"(voornaamwoord) en "subj" voor "subject"(onderwerp)
  3. <b/>, dit plakt een lege regel, wat ruimte.

Merk op dat we de informatie van getal en tijd rechtstreeks van het werkwoord terugkrijgen.
Dus als we dit opnieuw samenstellen en dat opnieuw testen:

$ echo "vidim gramofone" | 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
I see gramophones

Dit is,terwijl het geen prijswinnende proza is(net zoals deze HOWTO), een redelijk accurate vertaling.

[edit] Over de 'record player' (Meerdere woorden)

Terwijl 'gramophone' een Engels woord is, is het niet de beste vertaling. 'Gramophone' wordt gebruikt voor die oude soort van muziekspelers, diegene met de naald, zonder enige versterking. Een betere vertaling zou 'record player' zijn. Hoewel dit meer dan 1 woord is, kunnen we het beschouwen alsof het 1 woord is door 'multiword' (multipalabra) constructies te gebruiken.
Daarvoor moeten we niets in het Servo-Kroatisch woordenboek gaan veranderen, maar enkel in het Engelse en het eentalige woordenboek. Open deze.
Het meervoud van 'record player' is 'record players', dus het gebruikt hetzelfde paradigma als 'gramophone'(gramophone__n). — Bij beide voorbeelden voegen we gewoon een 's' toe. Alles wat we moeten doen, is een nieuw elementen toevoegen aan de hoofdsectie.

<e lm="record player"><i>record<b/>player</i><par n="gramophone__n"/></e>

Het enige verschil is dat we nu de <b/> tag gebruiken. Dit is niet helemaal nieuw, we zijn dit ook al tegengekomen in het regelsbestand.
Zet alles dus opnieuw samen en test het zoals op de oude manier:

$ echo "vidim gramofone" | 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
I see record players

Perfect. Een groot voordeel is dat je 'multiwords' kan gebruiken om uitdrukkingen te vertalen, zonder woord voor woord te laten vertalen. Bv. de Engelse zin 'at the moment' zou in het Servo-Kroatisch 'trenutno'(trenutak = moment, trenutno being adverb of that) worden — Het is dus niet mogelijk om deze Engelse zin woord per woord naar het Servo-Kroatisch te vertalen.

[edit] Omgaan met kleine variaties

Servo-Kroatisch is een overkoepelende term voor verschillende standaard talen, dus er zijn verschillen in uitspraak en schrijfwijze. Er bestaat een cool fonetisch systeem dat je dingen kan schrijven zoals je ze uitspreekt. Een voorbeeld van de uitspraak van het pro-Servische klinker 'yat'. Het woord 'woordenboek' kan bv. eenderzijds "rječnik"(Ijekavian genoemd) of anderzijds "rečnik"(Ekavian genoemd) zijn.

[edit] Analyse

Er zou een gemakkelijke manier moeten bestaan om hiermee om te gaan, en die is er dankzij paradigma's. Paradigma's worden niet enkel gebruikt om grammaticale symbolen toe te voegen, maar ook om een karakter/symbool te vervangen door een ander. Bv. hier is een paradigma dat 'e' en 'je' accepteert in de analyse. Dit paradigma zou samen met de andere in het eentalige Servo-Kroatische woordenboek moeten komen.

  <pardef n="e_je__yat">
    <e>
      <p>
        <l>e</l>
        <r>e</r>
      </p>
    </e>
    <e>
      <p>
        <l>je</l>
        <r>e</r>
      </p>
    </e>
  </pardef>


Daarna in de hoofdsectie:

    <e lm="rečnik"><i>r</i><par n="e_je__yat"/><i>čni</i><par n="rečni/k__n"/></e>

Dit zorgt ervoor dat we beide vormen kunnen analyseren...maar er is meer werk nodig als we beide vormen willen genereren.

[edit] Genereren

[edit] Zie ook

Personal tools