View source for Come scrivere una nuova coppia di lingue Apertium

{{TOCD}}
Come scrivere una nuova coppia di lingue Apertium

Guida per la creazione di una nuova coppia di lingue per Apertium 

Questo documento è una guida che descrive i passaggi necessari per creare una nuova coppia di lingue per il software di traduzione automatica Apertium.

Non sono necessari conoscenze della linguistica o di sistemi automatici di traduzione, ma è comunque importante avere alcune nozioni di grammatica elementare. (verbi, sostantivi, preposizioni, ecc.)

==Introduzione==

Apertium, l’avrete già capito, è una piattaforma di traduzione automatica. Ma non soltanto, sono disponibili anche un motore e  un corredo di strumenti atti a  facilitare la creazione di un vostro sistema di traduzione. Basterà soltanto fornire dati appropriati. Per il livello base occorrono tre dizionari  e poche regole utili a riordinare le parole ed eseguire altre funzioni grammaticali  (queste stabiliranno, per esempio, l'ordine delle parole o cose simili).

Per ottenere informazioni più dettagliate riguardo il funzionamento dell'intero framework, è possibile dare un'occhiata alla pagina [[Publications]]...

==Avrai bisogno di==

* [[lttoolbox]] (>= 3.0.0)
* libxml utils (xmllint etc.)
* apertium (>= 3.0.0)
* un editor di testo (o un altro editor XML)

Questa guida non descriverà come installare i suddetti pacchetti. Consultare in merito la relativa documentazione nel sito del progetto Apertium.

==In cosa consiste una coppia di lingue?==

Apertium utilizza un tipo di traduzione  detto superficiale. Significa che il motore utilizza dizionari e regole di traduzione  superficiali. Questo tipo di traduzione  è diverso da quello detto approfondito perché non fa una completa analisi sintattica. Le regole eseguono operazioni su un gruppo di unità lessicali, invece che un’analisi ad albero. 
A livello base, ci sono tre dizionari principali: 
# Il dizionario morfologico per il linguaggio xx: questo contiene le regole secondo le quali i vocaboli della lingua xx sono coniugati. Nel nostro esempio sarà: <code>apertium-sh-en.sh.dix</code>
# Il dizionario morfologico per il linguaggio yy: questo contiene le regole secondo le quali i vocaboli della lingua yy sono coniugati. Nel nostro esempio sarà: <code>apertium-sh-en.en.dix</code>
# Il dizionario bilingue: contiene i vocaboli e i simboli corrispondenti nei due linguaggi. Nel nostro esempio sarà: <code>apertium-sh-en.sh-en.dix</code>

Nella coppia di lingue i due linguaggi sono intercambiabili: è possibile sia tradurre xx in yy sia il contrario.

I file che contengono le regole sono due. Questi descrivono le modalità secondo le quali le parole sono riordinate all'interno della frase una volta tradotta (es. gatto nero -> cat black -> black cat). Le regole si occupano anche di accordare i vocaboli in genere, numero, ecc. Come descritto più avanti, le regole possono inserire o rimuovere elementi lessicali. I due file sono:
# Le regole di trasferimento dalla lingua xx alla yy: questo file contiene le regole secondo le quali le parole della lingua xx verranno riordinate nella lingua yy. Nel nostro esempio sarà: <code>apertium-sh-en.sh-en.t1x</code>
# Le regole di trasferimento dalla lingua yy alla xx: questo file contiene le regole secondo le quali le parole della lingua yy verranno riordinate nella lingua xx. Nel nostro esempio sarà: <code>apertium-sh-en.en-sh.t1x</code>

Alcune delle coppie di lingue attualmente disponibili hanno altri file, ma in questa sezione non verranno trattati. Quelli appena descritti sono gli unici file richiesti per ottenere un traduttore funzionante.

==Coppia di lingua==

Com'è prevedibile dai nomi dei file presi in esempio, questa guida farà uso delle lingue serbo-croato e inglese per mostrare come creare un sistema basilare di traduzione. Non è una coppia facile da trattare dal momento che il sistema di traduzione funziona meglio se applicato a lingue simili. Questo non dovrebbe però rappresentare un problema per i semplici esempi mostrati qui.

==Brevi note sui termini usati==

Prima di procedere, è necessario capire precisamente cosa si intende con alcuni termini.

Il primo è il termine ''lemma''. Il lemma è la semplice parola privata di qualsiasi informazione grammaticale. Per esempio, il lemma della parola ''gatti'' è ''gatto''. Pertanto i lemmi dei sostantivi italiani saranno singolari. Per quanto riguarda i verbi, il lemma sarà dato dall'infinito presente (es. il lemma di ''ero'' sarà ''essere'').

Il secondo termine è ''simbolo''. Nel contesto del progetto Apertium, i simboli si riferiscono ad "etichette grammaticali". Il sostantivo ''gatti'' è un sostantivo plurale, pertanto avrà un' etichetta grammaticale (un ''simbolo'', quindi) che lo contrassegnerà come nome e un'altra che lo contrassegnerà come plurale. Nel sistema di input/output di Apertium, questi simboli sono descritti all'interno di parentesi angolari come mostrato:

* <code><n></code>; per i nomi.
* <code><pl></code>; per i plurali.

Altri esempi di simboli sono <sg> per il singolare, <p1> per la prima persona, <pri> per il presente indicativo, ecc. Si noti come spesso i simboli sono abbreviazioni o acronimi dei termini a cui si riferiscono.

Il terzo termine è ''paradigma''. Nel contesto del progetto Apertium, il termine paradigma si riferisce a una sorta di modello che descrive come i vocaboli sono coniugati. Nel dizionario morfologico, i lemmi sono collegati con i paradigmi in quanto ci permettono di determinare come un vocabolo si presenti una volta coniugato senza doverlo riscrivere con tutte le desinenze possibili.

Per esempio se vogliamo inserire nel dizionario i due aggettivi ''felice'' e ''pigro'', invece di inserire ogni volta le desinenze di ciascuno:

* felice, felic (e, issimo)
* semplice, semplic (e, issimo)

Possiamo semplicemente inserirne uno e dire "semplice, si declina come felice", oppure "triste, si declina come felice", "gentile, si declina come felice", ecc. Nell'esempio, felice rappresenta il paradigma, il modello seguito per la coniugazione degli altri aggettivi simili. Una descrizione più approfondita di come si determina questa relazione verrà data a breve. I paradigmi sono definiti tramite il tag <pardef> e usati all'interno del tag <par>.

==Iniziare==

===I dizionari monolingue===
{{see-also|List of dictionaries|Incubator}}
Cominciamo col creare il nostro primo dizionario. Il dizionario sarà costituito da un file XML. Apri il tuo editor di testo e scrivi quello che segue:
<pre>
<?xml version="1.0" encoding="UTF-8"?>
<dictionary>

</dictionary>
</pre>
Il file che otteniamo indica semplicemente che stiamo creando un dizionario. Per renderlo funzionante, però, dobbiamo inserire altre informazioni, la prima è l'alfabeto. Questo stabilisce quali lettere possono essere usate all'interno della lingua che stiamo definendo. Per il serbo-croato, l'alfabeto che stiamo andando a definire risulterà come:
<pre>
<alphabet>ABCČĆDDžĐEFGHIJKLLjMNNjOPRSŠTUVZŽabcčćddžđefghijklljmnnjoprsštuvzž</alphabet>
</pre>

È necessario porre l'alfabeto all'interno del tag <dictionary>.

Adesso definiamo alcuni simboli. Cominciamo con cose semplici: nomi (n) al singolare (sg) e al plurale (pl).
<pre>
<sdefs>
   <sdef n="n"/>
   <sdef n="sg"/>
   <sdef n="pl"/>
</sdefs>
</pre>
I nomi dei simboli non devono per forza essere brevi ma, dal momento che dovrai ricordarli e scriverli spesso, conviene abbreviarli.

Sfortunatamente il caso trattato non è così semplice, i nomi in serbo-croato si declinano in caso, genere e numero. Tuttavia, allo scopo dell'esempio, consideremo che il nome sia maschile e al caso nominativo (un esempio completo si può trovare alla fine di questa guida).

La prossima cosa da definire è la sezione per i paradigmi:
<pre>
<pardefs>

</pardefs>
</pre>
e la sezione del dizionario vero e proprio:
<pre>
<section id="main" type="standard">

</section>
</pre>
Ci sono due tipi di sezioni, il primo è dato dalla sezione standard che contiene i vocaboli, ecc. Le sezioni di secondo tipo sono facoltative e definiscono la punteggiatura e così via. Nel caso trattato mancherà la sezione facoltativa.

A questo punto il nostro file dovrebbe assomigliare a qualcosa come:
<pre>
<?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>
</pre>
Ora che abbiamo messo in piedi lo scheletro, possiamo cominciare ad aggiungere un nome. Il nome in questione sarà 'gramofon' (che sarebbe il 'grammofono').

Dal momento che non ne abbiamo, la prima cosa da fare è definire un paradigma.

Ricorda che stiamo stabilendo per convenzione di usare il genere maschile e il caso nominativo. La forma singolare del nome è 'gramofon' e il plurale è 'gramofoni'. Allora:
<pre>
<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>
</pre>
Nota: '<l/>' (equivalente a <l></l>) denota che non bisogna aggiungere nessun carattere a 'gramofon' per ottenere il singolare.

Probabilmente ti starai chiedendo per cosa stanno <e>, <p>, <l> e <r>. Bene,

* e, sta per entry (indica l'inserimento di un nuovo elemento).
* p, sta per pair (indica la coppia).
* l, sta per left (indica la parola vera e propria).
* r, sta per right (indica gli elementi grammaticali che caratterizzano la parola).

perché destra e sinistra? Bene, i dizionari morfologici alla fine andranno compilati. Compilarli da sinistra a destra significa produrre un analizzatore, mentre compilarli da destra a sinistra significa produrre un generatore. Il prodotto della compilazione (analizzatore o generatore) sarà in grado, a partire da un input, di produrre un output coerente con la modalità in cui è stato creato. L'esempio farà capire meglio:
<pre>
* da sinistra a destra: gramofoni ---> gramofon<n><pl> (analizzatore)
* da destra a sinistra: gramofon<n><pl> ---> gramofoni (generatore)
</pre>
Ora che abbiamo definito il paradigma, dobbiamo collegarlo con il rispettivo lemma, gramofon. Quest'operazione andrà fatta nella sezione che abbiamo definito.

L'elemento da inserire all'interno di <section> sarà:
<pre>
   <e lm="gramofon">
     <i>gramofon</i>
     <par n="gramofon__n"/>
   </e>
</pre>
Chiariamo velocemente le abbreviazioni:

* lm, sta per lemma.
* i, sta per identità (destra e sinistra sono gli stessi).
* par, sta per paradigma.

Quest'elemento stabilisce il lemma da collegare alla parola (gramofon), la radice (gramofon) e il paradigma con il quale il vocabolo viene flesso. La differenza tra il lemma e la radice è data dal fatto che il lemma è il termine vero e proprio al quale ci si riferisce, mentre la radice è la parte fissa del vocabolo alla quale vengono poi aggiunte le desinenze. Questa differenza diventerà più chiara quando verrà mostrato un elemento in cui lemma e radice differiscono.

Ora siamo pronti a testare il dizionario. Salvalo e apri un terminale. Innanzitutto dobbiamo compilarlo (con lt-comp), in seguito potremmo testarlo (con lt-proc).
<pre>
$ lt-comp lr apertium-sh-en.sh.dix sh-en.automorf.bin
</pre>
Dovrebbe produrre l'output:
<pre>
main@standard 12 12
</pre>
Avendolo compilato da sinistra a destra, abbiamo prodotto un analizzatore. Creiamo pure un generatore:
<pre>
$ lt-comp rl apertium-sh-en.sh.dix sh-en.autogen.bin
</pre>
A questo punto il comando dovrebbe produrre lo stesso output di prima.

Possiamo ora testarli. Eseguiamo lt-proc sull'analizzatore.
<pre>
$ lt-proc sh-en.automorf.bin
</pre>
Ora provalo, scrivi gramofoni (plurale di gramofon), e osserva l'output:
<pre>
^gramofoni/gramofon<n><pl>$
</pre>
Ora, per il dizionario di inglese, fai le stesse cose, ma sostituisci il a gramofon il corrispettivo inglese e cambia la flessione al plurale. Cosa dovresti fare per utilizzare all'interno del dizionario il più corretto 'record player' piuttosto che 'gramophone'? Bene, spiegheremo più avanti come fare.

Una volta fatto tutto, dovresti avere due file nella cartella:

* apertium-sh-en.sh.dix che contiene un dizionario morfologico serbo-croato (molto) scarno, e
* apertium-sh-en.en.dix che contiene un dizionario morfologico inglese (molto) scarno.

===Il dizionario bilingue===

Bene, ora abbiamo due dizionari morfologici, la prossima cosa da fare è creare il dizionario bilingue. Questo stabilisce le corrispondenze tra le parole. Tutti i dizionari usano lo stesso formato (che è specificato in DTD, dix.dtd).

Crea un nuovo file, apertium-sh-en.sh-en.dix e aggiungi lo scheletro base:

<pre>
<?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>
</pre>
Ora dobbiamo aggiungere l'elemento per tradurre le parole da una lingua all'altra. Qualcosa come:
<pre>
   <e>
     <p>
       <l>gramofon<s n="n"/></l>
       <r>gramophone<s n="n"/></r>
     </p>
   </e>
</pre>
Dato che dovranno essere aggiunti molti elementi come questo, di solito vanno scritti su un'unica riga per facilitare la lettura del file. Qui non si trovano sulla stessa riga per facilitarne la comprensione.
Anche qui troviamo 'l' (left) e 'r' (right). Se compiliamo questo dizionario da sinistra a destra otterremo un dizionario serbo-croato → inglese, se lo compiliamo da destra a sinistra otterremo un dizionario inglese → serbo-croato.

A questo punto procediamo eseguendo i seguenti comandi:
<pre>
$ 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
</pre>
Per generare l'analizzatore morfologico (automorf), il generatore morfologico (autogen) ed il dizionario stesso (autobil, dove bil sta per "bilingue").

===Le regole di trasferimento===

Bene, ora abbiamo due dizionari morfologici e un dizionario bilingue. Tutto ciò di cui necessitiamo ora sono delle regole di trasferimento per i nomi. I file che contengono le regole di trasferimento hanno il loro DTD (tansfer.dtd) che può essere trovato nel pacchetto di Apertium. Se hai bisogno di implementare una regola, si potrebbe rivelare una buona idea quella di guardare prima tra le regole di altre coppie di lingue. Alcune regole possono essere riutilizzate anche tra lingue diverse.

Cominciamo come abbiamo già fatto con lo scheletro base:
<pre>
<?xml version="1.0" encoding="UTF-8"?>
<transfer>

</transfer>
</pre>
Al momento, dato che stiamo ignorando il caso del vocabolo, dobbiamo solo creare la regola che prende come input i simboli grammaticali e li restituisce nuovamente nell'output.

Dobbiamo prima definire le categorie e gli attributi. Le categorie e gli attributi ci permettono di raggruppare simboli grammaticali. Le categorie ci consentono di raggruppare simboli in base all'aderenza a un pattern (es. 'n.*' comprenderà tutti i nomi). Gli attributi ci consentono di raggruppare alcuni simboli variabili riferiti allo stesso oggetto(es. 'sg' e 'pl' possono essere raggruppati sotto l'attributo 'number').

Aggiungianmo le sezioni necessarie:
<pre>
<section-def-cats>

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

</section-def-attrs>
</pre>
Dato che stiamo flettendo i nomi solo in numero (o singolare o plurale), avremo bisogno di aggiungere una categoria per i nomi con l'attributo del numero. Qualcosa come quello che segue sarà sufficiente.

Aggiungi in section-def-cats:
<pre>
<def-cat n="nom">
   <cat-item tags="n.*"/>
</def-cat>
</pre>
Questo rintraccerà tutti i nomi (i lemmi seguiti da <n>) e si riferirà a loro come "nom" (vedremo l'utilità di questa operazione in seguito).

Aggiungi in section-def-attrs:
<pre>
<def-attr n="nbr">
   <attr-item tags="sg"/>
   <attr-item tags="pl"/>
</def-attr>
</pre>
e poi
<pre>
<def-attr n="a_nom">
   <attr-item tags="n"/>
</def-attr>
</pre>
Il primo definisce l'attributo nbr (numero), che può assumere il valore di singolare (sg) o plurale (pl).

Il secondo definisce l'attributo a_nom (attributo del nome).

La prossima cosa di cui abbiamo bisogno è una sezione per le variabili globali:
<pre>
<section-def-vars>

</section-def-vars>
</pre>
Queste variabili sono utilizzate per memorizzare o scambiare gli attributi tra le regole. Per il momento abbiamo bisogno di definirne solo una,
<pre>
<def-var n="number"/>
</pre>
Infine, dobbiamo aggiungere una regola per prendere il nome in input e per produrre l'output in forma corretta. Avremo bisogno di una sezione per le regole...
<pre>
<section-rules>

</section-rules>
</pre>
Ecco qui a seguire un esempio di regola:
<pre>
<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>
</pre>

Il primo tag, è ovvio, definisce la regola. Il secondo tag è dato dal pattern e significa: "applica questa regola se questo pattern è riscontrato". In questo esempio il pattern è dato da un singolo nome (definito dalla categoria nom). Nota che i pattern sono applicati a partire dal più lungo. Se, per esempio, si hanno tre regole di cui la prima verifica la presenza del pattern "<prn><vblex><n>", la seconda del pattern "<prn><vblex>" e la terza del pattern "<n>", il pattern a venir verificato prima sarà il più lungo ovvero il primo.

A ciascun pattern è associata un'azione che produce un dato output (out). L'output è un'unità lessicale (lu).

Il tag clip permette all'utente di selezionare e manipolare gli attribuiti e le parti del lessico della lingua di partenza (side="sl"), o della lingua di arrivo (side="tl").

Compiliamolo e testiamolo. Le regole di trasferimento sono compilate con:
<pre>
$ apertium-preprocess-transfer apertium-sh-en.sh-en.t1x sh-en.t1x.bin
</pre>
Che genererà il file <code>sh-en.t1x.bin</code>.

Ora siamo pronti a testare il nostro sistema di traduzione automatica. Manca ancora una parte cruciale, l'attributo part-of-speech (PoS), ma verrà illustrata a breve. Nel frattempo possiamo testare il sistema così com'è:

Per prima cosa analizziamo una parola, gramofoni:
<pre>
$ echo "gramofoni" | lt-proc sh-en.automorf.bin 
^gramofon/gramofon<n><pl>$
</pre>
Ora, normalmente qui il tagger POS avrebbe scelto la giusta versione in base alla parte del discorso, ma non avendo ancora il tagger POS, possiamo usare un piccolo script gawk (grazie a Sergio) che semplicemente mostrerà il primo termine ottenuto.
<pre>
$ 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>$
</pre>
Ora processiamolo con la regola di trasferimento:
<pre>
$ 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
</pre>
Questo produrrà come output:
<pre>
^gramophone<n><pl>$^@
</pre>

* 'gramophone' è il lemma (lem) della lingua finale (side="tl") alla posizione 1 (pos="1").
* '<n>' è l'attributo del nome (a_nom) della lingua finale alla posizione 1.
* '<pl>' è l'attributo numero (nbr) della lingua finale alla posizione 1.

Prova a commentare una dichiarazione del tag clip, ricompila e osserva che succede.

Bene, ora che abbiamo l'output del "trasferitore", l'unica cosa che rimane da generare sono le forme flesse del linguaggio finale. Allo scopo useremo lt-proc ma come generatore (-g), non come analizzatore.
<pre>
$ 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\@
</pre>
E ci siamo! Ora hai un sistema di traduzione automatica che traduce un nome dal serbo-croato all'inglese. Ovviamente questo non è molto utile, ma ci addentreremo presto in cose più complesse. Non preoccuparti per il simbolo '@', lo spiegheremo presto. 

Pensa un altro po' di parole che si flettono allo stesso modo di gramofon. Come aggiungerli? Non abbiamo bisogno di aggiungere altri paradigmi, basterà aggiungere l'elemento nella sezione principale del dizionario monolingue e bilingue.

==Passiamo ai verbi==

Bene, ora abbiamo un sistema che traduce i nomi. Ma per creare qualcosa di veramente utile dobbiamo poter tradurre i verbi e perfino intere frasi! Per mostrare come fare, utilizzeremo il verbo inglese ''to see''. La rispettiva traduzione in serbo-croato è ''videti''. Il serbo-croato è una lingua che non necessita di soggetto, questo significa che non hanno bisogno del pronome personale che compie l'azione descritta dal verbo. L'inglese è diverso. Per esempio: ''I see'' sarebbe tradotto in serbo-croato come ''vidim''.

* vidim
* see<p1><sg>
* I see

Nota: <code><p1></code> indica che si tratta di una prima persona.

Questo sarà importante quando arriveremo a trattare delle regole di trasferimento per i verbi. Altri esempi di lingue che non necessitano di soggetto sono: italiano, spagnolo, rumeno e polacco. Questo significa anche che se nel dizionario morfologico serbo-croato dobbiamo inserire solo il verbo, nel dizionario morfologico inglese dovremo inserire sia il verbo che il pronome personale. Esamineremo anche questi casi.

Le altre persone del verbo videti sono: vidiš, vidi, vidimo, vidite, e vide; queste corrispondono rispettivamente a vedi, vede, vediamo, vedete, vedono.

A questo punto proviamo a tradurre la frase "Vidim gramofoni" in "I see gramophones". Per ragioni di spazio, aggiungeremo soltanto le informazioni basilari per fare la traduzione, mentre lasceremo il lavoro di aggiungere i paradigmi del verbo come esercizio per il lettore. 

L'astuto lettore avrà realizzato che ancora non possiamo tradurre correttamente vidim gramofoni poiché non è grammaticalmente corretto in serbo-croato. La frase corretta sarebbe vidim gramofone in quanto il nome va coniugato in caso accusativo. Dovremo aggiungere anche questa forma. Tuttavia, per il momento, non è necessario aggiungere informazioni sul caso.

La prima cosa che dobbiamo fare è aggiungere qualche simbolo. Dobbiamo prima aggiungere il simbolo per 'verb', che chiameremo 'vblex' (che significa verbo lessicale, il contrario dei verbi modali e di altri tipi). I verbi hanno la persona ('person') e il tempo ('tense') oltre che il numero, pertanto aggiungiamone un paio. Dobbiamo tradurre "I see", aggiungeremo, quindi, "p1" (prima persona) per la persona e "pri" (presente indicativo) per il tempo.
<pre>
<sdef n="vblex"/>
<sdef n="p1"/>
<sdef n="pri"/>
</pre>
Fatto ciò, allo stesso modo dei nomi, aggiungeremo un paradirma per la coniugazione dei verbi. La prima riga sarà:
<pre>
<pardef n="vid/eti__vblex">
</pre>
La '/' è utilizzata per indicare il punto in cui verranno aggiunte le desinenze (le parti racchiuse tra <l> e </l>).

A questo punto aggiungiamo la flessione per la prima persona singolare:
<pre>

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

</pre>
La parte 'im' indica la terminazione (per formare 'vid-im') del verbo. È necessario, poi aggiungere 'eti' nella sezione dato che nella definizione questa sarà tagliata via. Il resto è piuttosto chiaro: 'vblex' indica che il verbo in questione è lessicale, 'pri' indica che si tratta di un presente indicativo, 'p1' indica che si tratta di una prima persona mentre 'sg' afferma che il numero è singolare. Possiamo anche aggiungere il plurale che sarà molto simile eccetto per la terminazione (che sarà 'imo') e per il numero (che sarà 'pl').

Completato anche questo passiaggio, dobbiamo definire il lemma nella sezione principale:
<pre>
<e lm="videti">
  <i>vid</i>
  <par n="vid/eti__vblex"/>
</e>
</pre>
Nota: il contenuto di <nowiki><i> </i></nowiki> è la radice, non il lemma.

Questo è quanto per quel che riguarda il dizionario serbo-croato di cui abbiamo parlato fino ad ora. Compiliamolo e testiamolo:
<pre>
$ 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>$
</pre>
Bene, ora non ci rimane che fare la stessa cosa per il dizionario di inglese (ricordati di aggiungere le stesse definizioni dei simboli che hai aggiunto nel dizionario serbo-croato).

Il paradigma è:
<pre>
<pardef n="s/ee__vblex">
</pre>
poiché il passato fa 'saw'. Aggiungiamo, quindi, un'elemento per 'see' e assegnamogli solo il simbolo 'pri'.
<pre>

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

</pre>
e come sempre, un nuovo elemento anche nella sezione principale:
<pre>
<e lm="see">
  <i>s</i>
  <par n="s/ee__vblex"/>
</e>
</pre>
Salviamo, ricompiliamolo e testiamolo:
<pre>
$ 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>$
</pre>

Ora aggiungiamo l'elemento anche nel dizionario bilingue:
<pre>
<e><p><l>videti<s n="vblex"/></l><r>see<s n="vblex"/></r></p></e>
</pre>
(non dimenticare di aggiungere le sdefs all'interno del file)

E ricompila:
<pre>
$ 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
</pre>
Ora testalo:
<pre>
$ 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>$^@
</pre>
Vediamo che l'analisi è andata avanti senza problemi ma otteniamo un '#' come mostrato:
<pre>
$ 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\@
</pre>
Il '#' significa che il generatore non riesce a generare la forma lessicale corretta poiché non la contiene. perché accade questo?

In pratica l'analisi non trova corrispondenza, il 'see' nel dizionario è see<vblex><pri>, ma il see inviato dal "trasferitore" è see<vblex><pri><p1><sg>. La parte serbo-croata del dizionario possiede più informazioni di quelle richieste dalla parte inglese. Puoi testare questo comportamento aggiungendo i simboli mancanti al dizionario inglese, ricompilandolo e testandolo nuovamente.

Tuttavia, il modo migliore per risolvere questo comportamento è scrivere una regola. Quindi apri il file delle regole (<code>apertium-sh-en.sh-en.t1x sh-en.t1x.bin sh-en.autobil.bin</code> in caso ne avessi dimenticato il nome).

Aggiungiamo una nuova categoria per 'verb'.
<pre>
<def-cat n="vrb">
   <cat-item tags="vblex.*"/>
</def-cat>
</pre>
Dobbiamo anche aggiungere gli attributi per il tempo e per la persona. Per motivi di spazio aggiungeremo solo la prima persona ma è possibile aggiungere anche p2 e p3.
<pre>
<def-attr n="temps">
   <attr-item tags="pri"/>
</def-attr>

<def-attr n="pers">
   <attr-item tags="p1"/>
</def-attr>
</pre>
Dovremo anche aggiungere un attributo per i verbi.
<pre>
<def-attr n="a_verb">
   <attr-item tags="vblex"/>
</def-attr>
</pre>
Ora scriviamo tra le regole:
<pre>
<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>
</pre>
Ricorda che se commenti i tag 'clip' nell'esempio di regola appena visto, essi scompariranno nell'output. Possiamo così prendere in entrata un verbo con tutta l'analisi, ma produrre un output contenente un'analisi parziale (lemma + tag verbo + tag tempo)

Adesso, se ricompiliamo il tutto, otteniamo:
<pre>
$ 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>$^@
</pre>
e:
<pre>
$ 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\@
</pre>
Provalo con 'vidimo' (we see) per vedere se ottieni l'output corretto.

Prova ora con "vidim gramofone":
<pre>
$ 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\@
</pre>

==E il pronome personale?==

Bene, siamo a buon punto ma ci manca ancora il pronome personale che è necessario nella lingua inglese. Per aggiungerlo, dobbiamo prima modificare il dizionario morfologico inglese.

Come già visto, la prima cosa da fare è aggiungere i simboli necessari:
<pre>
<sdef n="prn"/>
<sdef n="subj"/>
</pre>
Dei due simboli, prn è il pronome, e subj è il soggetto (come il soggetto di una preposizione).

poiché non c'è radice o lemma per il pronome personale soggetto, ci basta aggiungere il ''pardef'' come segue:
<pre>
<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>
</pre>
Dove 'prsubj' sta per 'personal subject' (personale soggetto). I rimanenti (You, We, ecc.) saranno un esercizio per il lettore.

Possiamo aggiungere un elemento nella sezione principale come segue:
<pre>
<e lm="personal subject pronouns">
  <i/>
  <par n="prsubj__prn"/>
</e>
</pre>
A questo punto salva, ricompila e testa. Dovremmo ottenere qualcosa come:
<pre>
$ echo "I" | lt-proc en-sh.automorf.bin
^I/PRPERS<prn><subj><p1><sg>$
</pre>

(Nota: è in lettere maiuscole perché ''I'' è in maiuscolo).

Ora dobbiamo correggere la regola 'verb' per dare come output anche il pronome personale.

Prima, aggiungiamo una categoria:
<pre>
<def-cat n="prpers">
   <cat-item lemma="prpers" tags="prn.*"/>
</def-cat>
</pre>
Ora aggiungiamo i tipi di pronome come attributi, possiamo anche aggiungere il tipo 'obj' (oggetto) anche se non ne faremo uso per il momento:
<pre>
<def-attr n="tipus_prn">
   <attr-item tags="prn.subj"/>
   <attr-item tags="prn.obj"/>
</def-attr>
</pre>
Ed ecco la regola:
<pre>
<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>
</pre>
Assomiglia quasi alla stessa regola di prima ma sono state fatte un paio di semplici modifiche.

Abbiamo bisogno di ottenere come output:
<pre>
^prpers<prn><subj><p1><sg>$ ^see<vblex><pri>$
</pre>
così che il generatore possa scegliere il pronome corretto e la giusta forma del verbo.


Ecco un breve riassunto:

* <code><lit></code>, stampa una stringa, in questo caso "prpers".
* <code><lit-tag></code>, stampa un tag; poiché non possiamo ottenere i tag a partire dal verbo, li aggiungiamo noi stessi, "prn" per il pronome e "subj" per il soggetto.
* <code><b/></code>, stampa uno spazio vuoto.

Nota che abbiamo ricavato le informazioni del numero e del tempo direttamente dal verbo.

Se ora ricompiliamo e testiamo nuovamente otteniamo:
<pre>
$ 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
</pre>
Che, sebbene non sia qualcosa di sensazionale, è una traduzione piuttosto accurata. 

==Parlami un po' di 'record player' (parole multiple)==

Sebbene gramophone sia una parola inglese, non è certamente la miglior traduzione. Gramophone è usata solitamente per descrivere il vecchio tipo di apparecchio (quello con l'ago al posto del pennino e senza amplificazione elettrica). Una traduzione migliore del termine sarebbe 'record player'. Anche se è composta da più di un vocabolo, è possibile trattarla come se fosse un'unica parola usando la costruzione delle parole multiple.

Non abbiamo bisogno di incidere né sul dizionario serbo-croato né su quello bilingue, ma solo su quello inglese. Aprilo, pertanto.

Il plurale di 'record player' è 'record players', puoi usare infatti lo stesso paradigma di gramophone (gramophone__n) — nel senso che ci basta aggiungere solo la 's'. Tutto quello che dobbiamo fare è aggiungere un nuovo elemento alla sezione principale.
<pre>
<e lm="record player">
  <i>record<b/>player
  </i>
  <par n="gramophone__n"/>
</e>
</pre>
L'unica differenza è l'uso del tag <b/>, che non ci è del tutto nuovo avendolo visto nel file delle regole.

Bene, ricompilato e testalo nel solito modo:
<pre>
$ 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
</pre>
Perfetto. Uno dei maggiori benefici dell'uso delle parole multiple è che puoi tradurre modi di dire senza dover fare la traduzione parola per parola. Per esempio l'espressione inglese "at the moment" sarebbe tradotta in serbo-croato come "trenutno" (trenutak = ''moment'', trenutno sarebbe l'avverbio). Non sarebbe stato possibile tradurre un'espressione del genere dall'inglese al serbo-croato col metodo del'analisi parola per parola.

==Avere a che fare con variazioni minori==

Il serbo-croato ha diversi modi di scrivere ciascuna parola a causa delle variazioni dialettali. Ha un interessante sistema di scrittura dato che si scrive nello stesso modo in cui si parla. Per esempio le persone che parlano Ijekavian direbbero "rječnik" intendendo quello che le persone che parlano Ekavian direbbero "rečnik". Questo riflette le differenze di pronuncia per la vocale proto-slava ''yat''.

===Analisi===

Queste situazioni si possono trattare in modo piuttosto semplice con l'uso dei paradigmi. I paradigmi non sono usati solo per aggiungere simboli grammaticali, ma anche per sostituire qualsiasi carattere/simbolo con un altro. Per esempio qui viene mostrato un paradigma che accetta sia "e" e "je" nell'analisi. Il paradigma dovrebbe andare nel dizionario monolingue serbo-croato.

<pre>
  <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>
</pre>

Aggiungi poi nella sezione principale:

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

Questo ci permette soltanto di analizzare entrambe le forme tuttavia... è necessario più lavoro nel caso volessimo generare entrambe le forme.

===Generazione===

==Vedi anche==

*[[Building dictionaries]]
*[[Finding_errors_in_dictionaries]]
*[[Cookbook]] 
*[[Chunking]]
*[[Contributing to an existing pair]]

[[Category:Documentazione in italiano]]
[[Category:HOWTO]]
[[Category:Writing dictionaries]]