Multra är en prototyp till ett regelbaserat maskinöversättningssystem som utvecklats vid Institutionen för lingvistik vid Uppsala universitet. Det är primärt avsett för översättning av svensk facktext. översättning i Multra sker mening för mening. övergången mellan källspråk och målspråk sker via en abstrakt representation av den grammatiska strukturen i källspråksmeningen.
En väsentlig del av Multra är språkkomponenten. Den består av en svensk del, en översättningsdel och en målspråksdel. Var och en av dessa delar består i sin tur av en lexikal och en grammatisk del. För översättning inom ett visst ämnesområde och ett visst målspråk måste språkkomponenten definieras i särskild ordning. För den svenska delen kan man utgår från ett lexikon över allmänspråket och en kärngrammatik som utvecklats vid Institutionen för lingvistik. Vad gäller det ämnesspecifika lexikonet och översättningsdelen kan man utnyttja datamaskinella metoder för att extrahera termer och översättningsekvivalenter ur redan översatt text (Tiedemann 1998). Lexikonet för den domän till vilken Scanias servicelitteratur hänför sig upptar c:a 15.000 ord (lexikala enheter) och därav utgör allmänspråket närmare en tredjedel. Därtill kommer arbetet med att definiera strukturella översättningsregler samt att definiera en grammatik för målspråket, som bl.a. redogör för ordföljd.
|
Input
|
Process
|
Output
|
Språkliga resurser
|
|
Mening att översätta
|
ANALYS
|
Satslösningsstruktur(er) på källspråket
|
Lexikon och grammatik för källspråket
|
|
Satslösningsstruktur(er) på källspråket
|
PREFERENS
|
Satslösningsstruktur(er) i preferensordning
|
Preferensregler
|
|
Satslösningsstruktur(er) i preferensordning
|
TRANSFER
|
Satslösningsstruktur(er) på målspråket
|
Lexikala och strukturella transferregler
|
|
Satslösningsstruktur(er) på målspråket
|
GENERERING
|
översatt mening
|
Lexikon och grammatik för målspråket
|
Tabell 1: Skiss över de olika stegen i översättningssystemet Multra
Tippa hytten. :
(* = (PHR.CAT = CL
TYPE = IMP
PRED = (VERB = (WORD.CAT = VERB
INFF = IMP
DIAT = ACT
LEX = TIPPA.VB.1)
OBJ.DIR = (PHR.CAT = NP
NUMB = SING
GENDER = UTR
CASE = BASIC
DEF = DEF
HEAD = (LEX = HYTT.NN.1
WORD.CAT = NOUN)))
REG = (V1.LEM = TIPPA.VB)
SEP = (WORD.CAT = SEP
LEX = STOP.SR.0)))
(15 VERTICES)
>
> (show)
1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15|
.-T-.-i-.-p-.-p-.-a-.-_-.-h-.-y-.-t-.-t-.-e-.-n---.-.-.-_-.
.-t-. .-HYTT.NN-----------------.STOP.SR.
.-TIPPA.VB--------------.-NP----------------------.
.-TIPPA.VB--------------. .FORM.SUFF.
.-CL------------------------------------------------------.
1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15|
> (type chart 1 1)
1--1 Creator: 18
LR-Action: Consult dictionary SVE.DIC
1--1 Creator: 4
LR-Action: CL.IMP;
1--1 Creator: 4
LR-Action: CL.DECL;
1--1 Creator: 4
LR-Action: Consult dictionary SVE.DIC
1--1 Creator: 4
LR-Action: CONVERT.CASE;
1--1 Creator: 0
LR-Action: START.RULE;
> (type chart 7 7)
7--7 Creator: 170
LR-Action: NP_NOUN;
7--7 Creator: 106
LR-Action: Consult dictionary SVE.DIC
SVE.GRAM START.RULE
-------------------
PROCESS(CONVERT.CASE), PROCESS.DIC, PROCESS(CL.DECL), PROCESS(CL.IMP);
Inactive filter
CHAR;
SVE.GRAM CL.IMP
---------------
<& PHR.CAT> :=: 'CL,
NOT <* PHR.CAT> = 'CL,
<& TYPE> :=: 'IMP,
<* WORD.CAT> = 'VERB,
<& PRED VERB WORD.CAT> :=: 'VERB,
<* INFF> = 'IMP,
<& PRED VERB INFF> :=: <* INFF>,
<& REG V1.LEM> :=: <* LEM>,
<& PRED VERB DIAT> :=: <* DIAT>,
ADVANCE,
(ADVERBIALS1// CONTINUE),
DO(<& REG V1.LEM :VERBCOMP>),
DO(<& PRED VERB LEX :VERBACTION>), ADVANCE,
(ADVERBIALS2, ADVANCE// CONTINUE),
(END.OF.SENT, STORE/ CL_COORD);
Inactive filter
WORD.CAT or PHR.CAT;
SVE.GRAM NP_NOUN
----------------
<* WORD.CAT> = 'NOUN,
<& PHR.CAT> :=: 'NP,
<& NUMB> :=: <* NUMB>,
(<& NUMB> :=: 'SING// <& NUMB> :=: 'PLUR),
<& GENDER> :=: <* GENDER>,
<& CASE> :=: <* CASE>,
<& DEF> :=: <* FORM>,
<& HEAD LEX> :=: <* LEM :LEX>),
<& HEAD WORD.CAT> :=: <* WORD.CAT>, STORE,
(ADVANCE(COORD.TEST)//
<* CASE> = 'GEN, MAJORPROCESS(NP_POSS)/
ADVANCE(POST.ATTR));
Inactive filter
WORD.CAT;
SVE.GRAM PATTERN.ÄLSKA
----------------------
ASSIGN.INFL('ÄLSKA),
ASSIGN.DICSTEM,
<& CONJ> :=: 'I,
<& DEPON> :=: '-,
ADVANCE,
(END.OF.WORD,
<& WORD.CAT> :=: 'VERB,
<& DIAT> :=: 'ACT,
(<& INFF> :=: 'INF//
<& INFF> :=: 'IMP), STORE.SINGLE.MORPH/
<& VOICE> :=: '+, VERB);
SVE.GRAM PATTERN.FILM
---------------------
ASSIGN.DICSTEM,
ASSIGN.INFL('FILM),
<& LAST.CHAR> :=: <* CHAR>,
(ASSIGN.STEM,
NOUN('-ER, 'UTR, 'CONS)//
ASSIGN.COMPSTEM,
(NOLINK//
ADVANCE,
<* CHAR> = 's,
NOT <& LAST.CHAR> = 's,
LINK(<* CHAR>)));
SVE.DIC tippa ------------- <& LEM> :=: 'TIPPA.VB, PATTERN.ÄLSKA;
TIPPA.VB -------- (LEX = TIPPA.VB.1 VERBCOMP = VC.TA)
TIPPA.VB.1 ---------- (VERBACTION = VA.OBJ+MANNER) SVE.DIC hytt ------------ <& LEM> :=: 'HYTT.NN, PATTERN.FILM; SVE.DIC HYTT.NN ------- (LEX = HYTT.NN.1)
[PRED : [VERB : [WORD.CAT : VERB
LEX : TILT.VB.0
DIAT : ACT
INFF : IMP]
OBJ.DIR : [PHR.CAT : NP
DEF : DEF
NUMB : SING
HEAD : [WORD.CAT : NOUN
LEX : CAB.NN.0]]]
TYPE : IMP
SEP : [WORD.CAT : SEP
LEX : STOP.SR.0]
PHR.CAT : CL]
Applying Rule PRED
Applying Rule VERB
Applying Rule VERB.FRAME
Applying Rule TIPPA.VB.1
Applying Rule OBJ.DIR
Applying Rule PHR.CAT
Applying Rule CASE
Applying Rule GENDER
Applying Rule DEF
Applying Rule NUMB
Applying Rule HEAD
Applying Rule NOUN.FRAME
Applying Rule HYTT.NN.1
Applying Rule TYPE
Applying Rule SEP
Applying Rule REG
Applying Rule PHR.CAT
Success!
LABEL REG SOURCE <* REG> = ANY TARGET <*> = <*> TRANSFER LABEL TYPE SOURCE <* TYPE> = ?TYPE TARGET <* TYPE> = ?TYPE TRANSFER LABEL SEP SOURCE <* SEP> = ?SEP TARGET <* SEP> = ?SEP TRANSFER LABEL PRED SOURCE <* PRED> = ?PRED1 TARGET <* PRED> = ?PRED2 TRANSFER ?PRED1 <=> ?PRED2 LABEL HEAD SOURCE <* HEAD> = ?HEAD1 TARGET <* HEAD> = ?HEAD2 TRANSFER ?HEAD1 <=> ?HEAD2 LABEL OBJ.DIR SOURCE <* OBJ.DIR> = ?OBJ.DIR1 TARGET <* OBJ.DIR> = ?OBJ.DIR2 TRANSFER ?OBJ.DIR1 <=> ?OBJ.DIR2 LABEL PHR.CAT SOURCE <* PHR.CAT> = ?PHR.CAT TARGET <* PHR.CAT> = ?PHR.CAT TRANSFER LABEL NUMB SOURCE <* NUMB> = ?NUMB TARGET <* NUMB> = ?NUMB TRANSFER LABEL DEF SOURCE <* DEF> = ?DEF TARGET <* DEF> = ?DEF TRANSFER LABEL GENDER SOURCE <* GENDER> = ANY TARGET <*> = <*> TRANSFER LABEL CASE SOURCE <* CASE> = ANY TARGET <*> = <*> TRANSFER LABEL OBJ.DIR SOURCE <* OBJ.DIR> = ?OBJ.DIR1 TARGET <* OBJ.DIR> = ?OBJ.DIR2 TRANSFER ?OBJ.DIR1 <=> ?OBJ.DIR2 LABEL PHR.CAT SOURCE <* PHR.CAT> = ?PHR.CAT TARGET <* PHR.CAT> = ?PHR.CAT TRANSFER LABEL WORD.CAT SOURCE <* WORD.CAT> = ?WORD.CAT TARGET <* WORD.CAT> = ?WORD.CAT TRANSFER LABEL VERB SOURCE <* VERB> = ?VERB1 TARGET <* VERB> = ?VERB2 TRANSFER ?VERB1 <=> ?VERB2
Tilt the cab.
Applying Rule CL.IMP
Applying Rule VERB.IMP.OBJ.DIR
Applying Rule NP1b
Success!
LABEL CL.IMP
X1 ---> X2 X3 :
<X1 PHR.CAT> = CL
<X1 PRED> = <X2>
<X1 TYPE> = IMP
<X1 SEP> = <X3>
LABEL VERB.IMP.OBJ.DIR
X1 ---> X2 X3 :
<X1 PHR.CAT> = VP
<X1 VERB> = <X2>
<X1 OBJ.DIR> = <X3>
LABEL NP1b
% NP --> the {process/processes}
X1 ---> X2 X3 :
<X1 PHR.CAT> = NP
<X1 DEF> = DEF
<X1 HEAD> = <X3>
<X3 NUMB> = <X1 NUMB>
<X2 WORD.CAT> = ART
<X2 LEX> = THE.AL.0
<X2 DEF> = DEF
<X2 STEM> = the
<X2 INI> = <X1 HEAD INI>
Structure to generate:
[WORD.CAT : ART
LEX : THE.AL.0
DEF : DEF
STEM : the
INI : CONS]
Realize as word.
Structure to generate:
[NUMB : SING
INI : CONS
WORD.CAT : NOUN
LEX : CAB.NN.0
PLT : -
STEM : cab]
Realize as word.