Learning Transfer Rules for Machine Translation from Parallel Corpora

Werner Winiwarter, University of Vienna

Department of Scientific Computing
Universitätsstraße 5,
A-1010 Vienna, Austria Journal of Digital
[email protected] Information Management

ABSTRACT: In this paper we present JETCAT, a [29], in which we had developed a translation system from
Japanese-English transfer-based machine translation Japanese into German. One main problem for that language
system. Our main research contribution is that the pair was the lack of training material, i.e. high quality Japanese-
transfer rules are not handcrafted but are learnt German parallel corpora, which was one of the reasons why
automatically from a parallel corpus. The system has we shifted our research focus to Japanese-English.
been implemented in Amzi! Prolog, which offers For the implementation of our machine translation system
scalability for large rule bases, full Unicode support for we have chosen Amzi! Prolog because it provides an
Japanese characters, and several APIs for the seamless expressive declarative programming language within the
integration of the translation functionality into common Eclipse Platform. It offers powerful unification operations
office environments. As a first user interface we have required for the efficient application of the transfer rules and
developed a translation environment under Microsoft full Unicode support so that Japanese characters can be
Word. The dynamic nature of our system allows for an used as textual elements in the Prolog source code. Amzi!
easy customization of the rule base according to the Prolog has also proven its scalability during past projects
user’s personal preferences by simply post-editing the where we accessed large bilingual dictionaries stored as
translation results, which leads to an automatic update. fact files with several 100,000 facts. Finally, it offers several
The user interface for Microsoft Word also provides the APIs, which makes it possible to run the translation program
possibility for the user to display token lists, parse in the background so that the users can invoke the translation
trees, and transfer rules, which makes JETCAT also a functionality from their familiar text editor. For example, we
very useful tool for language students. have developed a prototype interface for Microsoft Word using
Visual Basic macros.
Categories and Subject Descriptors
I.2.7 [Natural Language Processing]; Machine translation I.2.8 The rest of the paper is organized as follows. We first provide
[Problem Solving, Control Methods, and Search]:Graph and tree a brief discussion of related work in Sect. 2 and an overview
search strategies of the system architecture in Sect. 3. In Sect. 4 we describe
General Terms the preprocessing stages to prepare the input for the
Machine translation, Unicode acquisition and application of transfer rules. Section 5 gives
a formal account of the three generic types of transfer rules
Keywords: Japanese-English translation, Language transfer rules that we use in our system along with several illustrative
Received 10 Sep. 2007; Reviewed and accepted 27 Jan. 2008 examples. The processing steps for the acquisition of new
rules and the subsequent consolidation phase to avoid
1. Introduction overtraining are presented in Sect. 6. Finally, Sect. 7 focusses
Despite the large amount of effort invested in the development on the application of the transfer rules during translation and
of machine translation systems, the achieved translation the generation of the final natural language output. We close
quality is still appalling. One major reason is the missing the paper with some concluding remarks and an outlook on
ability to learn from translation errors through incremental future work in Sect. 8.
updates of the rule base.
In our research we use the bilingual data from the JENAAD 2. Related Work
corpus [27] comprising 150,000 Japanese-English sentence Research on machine translation has a long tradition (for
pairs from news articles to learn specific transfer rules from good overviews see [6, 7, 12, 21]). The state of the art in
the examples through structural matching between the parse machine translation is that there are quite good solutions for
trees for the source and target language. The rules are narrow application domains with a limited vocabulary and
generalized in a consolidation phase to avoid overtraining concept space. However, it is the general opinion that fully
and to increase the coverage for new input. Based on the automatic high quality translation without any limitations on
resulting rule base we have developed JETCAT (Japanese- the subject and without any human intervention is far beyond
English Translation using Corpus-based Acquisition of the scope of today’s machine translation technology, and
Transfer rules), a Japanese-English transfer-based machine there is serious doubt that it will be ever possible in the
translation system. future [8, 10].
Our current research work originates from the PETRA project It is very disappointing to have to notice that the translation
(Personal Embedded Translation and Reading Assistant) quality has not much improved in the last 10 years [26]. One

Journal of Digital Information Management
Volume 6 Number 4
August 2008 285

 Figure 1. System architecture

main obstacle on the way to achieving better quality is seen in Whereas the transfer rules learnt during acquisition are very
the fact that most of the current machine translation systems accurate and guarantee consistent translations, this specificity
are not able to learn from their mistakes [9]. Most of the reduces the coverage for new unseen data. Therefore, the
translation systems consist of large static rule bases with limited consolidation step generalizes transfer rules as long as such
coverage, which have been compiled manually with huge relaxations do not result in conflicts with other rules in the rule
intellectual effort. All the valuable effort spent by users on post- base.
editing translation results is usually lost for future translations. Finally, we perform the translation of a Japanese sentence
As a solution to this knowledge acquisition bottleneck, corpus- by first tagging and parsing the sentence and then invoking
based machine translation tries to learn the transfer knowledge the transfer module. It applies the transfer rules stored in the
automatically on the basis of large bilingual corpora for the rule base to transform the Japanese parse tree into the
language pair [3, 15]. Statistical machine translation [2], in its corresponding English parse tree. The latter is the input to
pure form, uses no additional linguistic knowledge to train both the generation module, which produces the surface form of
a statistical translation and target language model. The two the English sentence as character string. In the following
models are used to assign probabilities to translation candidates sections we give a more detailed technical description of the
and then to choose the candidate with the maximum score. For individual modules. We illustrate their mode of operation by
the first few years the translation model was built only at the using the sentence pair in Fig. 2 as a running example
word level, however, as the limitations became apparent, several throughout the rest of this paper.
extensions towards phrase-based translation [16, 18, 22] and
syntax-based translation [13, 28, 30] have been proposed. 4. Tagging and Parsing
Although some improvements in the translation quality could be We use Python scripts for the basic string operations to import
achieved, statistical machine translation has still one main the sentence pairs from the JENAAD corpus. For the part-of-
disadvantage in common with rule-based translation, i.e. an speech tagging of Japanese sentences we use a Japanese
incremental adaptation of the statistical model by the user is lexicon, which was compiled automatically by applying the
usually impossible. Japanese morphological analysis system ChaSen [19] to the
The most prominent approach for the translation of Japanese JENAAD corpus. Figure 3 shows the result produced by the
has been example-based machine translation [11, 20, 25]. It tagging module. It segments the Japanese input into morphemes
uses a parallel corpus to create a database of translation and tags each morpheme with its pronunciation, base form,
examples for source language fragments. The different part-of-speech, conjugation type, and conjugation form. The last
approaches vary in how they represent these fragments: as three columns are encoded as numerical categories. For the
surface strings, structured representations, generalized ease of the reader we have added Roman transcriptions,
templates with variables, etc. [1, 4, 5, 14]. However, most of approximate English equivalents of the numerical categories,
the representations of translation examples used in and contextual English translations.
example-based systems of reasonable size have to be The Japanese language uses postpositions instead of
manually crafted or at least reviewed for correctness [23] to prepositions. The postposition O indicates the direct object, the
achieve sufficient accuracy. theme particle WA the subject (in this sentence). The verb SURU
is used to derive verbs from sahen nouns (e.g. recognize from
recognition), and the phrase DE ARU KOTO changes an adjectival
3. System Architecture
noun into a noun (e.g. important into importance). Finally, the
The three main tasks that we have to perform in our system verb suffix RERU indicates passive voice and the auxiliary verb TA
are acquisition, consolidation, and translation. During past tense.
acquisition (see Fig. 1) we derive new transfer rules by using
The acquisition of the Japanese lexicon is performed in two
a Japanese-English sentence pair as input. Both sentences steps. We first create a lexicon entry for each Japanese word
are first analyzed by the tagging modules, which produce the in the corpus based on the tags assigned by ChaSen. For words
correct segmentations into word tokens associated with their with several different tags, we store one default tag and, in a
part-of-speech tags. The token lists are then transformed second step, learn word sense disambiguation rules based on
into parse trees by the parsing modules. The parse trees the local context. We had to correct some wrong tag
represent the input to the acquisition module, which uses a assignments by ChaSen, in particular regarding different uses
structural matching algorithm to discover new transfer rules. of postpositions.

286 Journal of Digital Information Management
Volume 6 Number 4
August 2008

 · simple constituents represent words or features (atom/
atom or atom),
· complex constituents represent phrases modeled as lists
of subconstituents.
Since the Japanese language uses postpositions and the
general structure of a simple sentence is sentence-initial
element, pre-verbal element, and verbal, it is much easier to
parse a Japanese sentence from right to left. Therefore, we
reverse the Japanese token list before we start with the
parsing process. The output of the parser for our example
sentence is (using Roman transcriptions of Japanese
words):
[vbl([hea(SURU/47), hef(3/1), sjc(NINSHIKI/17)]),
Figure 2. Example of sentence pair dob([apo(O/61), hea(KOTO/21), mvp([vbl([hea(DA/74),
hef(55/4), aux([hea(ARU/74), hef(18/1)]),
cap([hea(JUUYOU/18)])]), sub([apo(GA/61), hea(AKUSESU/
17), mno([hea(SHIJOU/2)]), mvp([vbl([hea(SURU/47), hef(3/
5), aux([hea(RERU/49), hef(6/4)]), aux([hea(TA/74),
hef(54/1)]), sjc(KAIZEN/17)])])])])]), aob([apo(NITOTTE/
63), hea(HATTEN/17), mno([hea(KEIZAI/2)]), mnp([apo(NO/
71), hea(ROSHIA/12)])]), sub([apo(WA/65), hea(WAREWARE/
14)])]
Figure 5 provides a more human-readable presentation of
the parse tree. We have added verbose descriptions of the
constituent categories. The category “head form” encodes
the conjugation type and conjugation form according to
ChaSen. We use the categories “adposition” and
“adpositional object” to also cover prepositions and
prepositional objects in English parse trees.
Figure 3. Example of Japanese token list
The grammar acquisition is achieved by aligning the token
lists with the parse trees and building a hierarchical graph
The English input is tagged by using an English lexicon, which as intermediate representation, which, at the end of the
is again automatically derived by applying the MontyTagger [17] acquisition process, is translated into Definite Clause
to JENAAD. The tagging module segments the English input Grammar rules.
into morphemes, and tags each morpheme with its base form
and part-of-speech tag from the Penn Treebank tagset [24]. Also If a punctuation mark such as a comma is followed by a non-
the tag assignments by MontyTagger had to be corrected in conjugated word, we use its tag as subtag for the following
several cases. Figure 4 shows the output for our example word to increase the discriminative power of the lexical
sentence, we added the verbose description of the part-of- tagging. We traverse the parse tree top-down and try to
speech tags for clarification. navigate the corresponding graph. Starting from an initial
node, we follow links representing tags of words to nodes
The parsing modules compute the syntactic structure of representing constituents. A link to a simple constituent
sentences based on the information in the token lists. The removes the word from the token list, whereas a link to a
Japanese and English grammars were learnt automatically from complex constituent keeps the word in the list and navigates
manually parsed sentences in the JENAAD corpus and are to the initial node of the corresponding subgraph. To leave a
formulated as Definite Clause Grammar rules. A sentence is subgraph we follow an exit link, which again leaves the word
modeled as a list of constituents. A constituent is defined as a intact and returns to the node from which the subgraph was
compound term of arity 1 with the constituent category as called. All nodes and links are stored as dynamic facts to
principal functor. We use three-letter acronyms to encode the enable an easy incremental adaptation. If there is no existing
constituent categories. Regarding the argument of a constituent link for a transition in the parse tree, we distinguish three
we distinguish two types: cases:
· if the transition is an exit link or if the target node exists,
then we add a new link,
· if the target node does not exist, then we also add a
new node,
· if the target node represents a complex constituent and
the corresponding subgraph does not exist, then we
also add a new subgraph.
Figure 6 shows the hierarchical graph built from our example
sentence. As can be seen we handle certain common
complex constituents, e.g. aux or mno, which only contain
hea, or hea and hef as subconstituents, like simple
constituents to facilitate the acquisition process. We also
learn rules to rearrange constituents for which the order in
the token list does not correspond to the order in the parse
Figure 4. Example of English token list tree. The resulting graph is highly non-deterministic,

Journal of Digital Information Management
Volume 6 Number 4
August 2008 287

therefore, we replace ambiguous transitions with more addition, we have chosen the same order of subconstituents
specific conditions starting from words, word and tag as in the Japanese parse tree. Figure 7 shows the English
sequences, two-word sequences, etc., until we reach a parse tree for our example.
deterministic representation. We have added explicit constituent categories for the
English sentences are parsed from left to right. To facilitate determiner type (e.g. definite) and syntactic features such as
the structural matching between Japanese and English number, comparison, tense, aspect, or voice. For each feature
parse trees during acquisition we tried to align the use of we have defined a default value (e.g. singular for number) so
constituent categories in the English grammar as best as that we only indicate a feature in the parse tree if its value
possible with corresponding Japanese categories. In differs from the default value.

5. Transfer Rules
One characteristic of our approach is that we model all
translation problems with only three generic types of transfer
rules. The transfer rules are stored as Prolog facts in the
rule base. We have defined three Prolog predicates for the
three different rule types. Therefore, for the rest of this paper,
when we talk about “transfer rules” we always refer to transfer
rules for machine translation in the more general sense, not
to logical rules in the strict sense of Prolog terminology. We
also use the terms “equal” and “equality” synonymously with
“unifiable” and “unifiability”.
In the next subsections we give an overview of the three
different rule types along with illustrative examples. For the
ease of the reader we use Roman transcription for the
Japanese examples instead of the original Japanese
characters.

5.1 Word Transfer Rules

For simple context-insensitive translations at the word level,
Figure 5. Example of Japanese parse tree the argument A1 of a simple constituent is changed to A2 by

Figure 6. Example of grammar acquisition

288 Journal of Digital Information Management
Volume 6 Number 4
August 2008

applying the following predicate, i.e. if the argument of a As can be seen, if we have to translate the phrase MINSHUKA NI
simple constituent is equal to argument condition A1, it is MUKETA (toward democratization), the application of the above
replaced by A2: rule only translates NI MUKETA and leaves the translation of
wtr(A1, A2). MINSHUKA to another transfer rule.

Example 1. The default transfer rule to translate the Japanese

noun SEKAI into the English counterpart world is stated as the 5.3 Phrase Transfer Rules
fact: The most common and most versatile type of transfer rules
wtr(SEKAI/2, world/nn). are phrase transfer rules, which allow to define elaborate
conditions and substitutions on phrases, i.e. arguments of
complex constituents:
5.2 Constituent Transfer Rules
The second rule type concerns the translation of complex ptr(C, Hea, Req1, Req2).
constituents to cover cases where both the category and the
Rules of this type change the argument of a complex
argument of a constituent have to be altered:
constituent with category C from A1 = Req1 ∪ Add to A2 =
ctr(C1, C2, Hea, A1, A2). Req2 ∪Add if hea(Hea) A1. To enable the flexible application
of phrase transfer rules, input A1 and argument condition
This changes a complex constituent C1(A1) to C2(A2) if the
Req1 are treated as sets and not as lists of subconstituents,
category is equal to category condition C1, the head is equal
i.e. the order of subconstituents does not affect the
to head condition Hea, and the argument is equal to argument
satisfiability of the argument condition. The application of a
condition A1.
transfer rule requires that the set of subconstituents in Req1
Example 2. The modifying noun (mno) with head KOKUSAI is is included in the argument A1 of the input constituent C(A1)
translated as modifying adjective phrase (maj) with head to replace Req1 by Req2. Besides Req1 any additional
international: constituents can be included in the input, which are
transferred to the output unchanged. This allows for an
ctr(mno, maj, KOKUSAI /2, [hea( KOKUSAI /2)],
efficient and robust realization of the transfer module
[hea(international/jj)]).
because one rule application changes only certain aspects
The head condition serves as index for the fast retrieval of of a phrase whereas other aspects can be translated by
matching facts during the translation of a sentence and other rules in subsequent steps. It is also possible to use
significantly reduces the number of facts for which the the special constant notex as argument of a subconstituent
argument condition has to be tested. in Req1, e.g. sub(notex). In that case the rule can only be
Constituent transfer rules can contain shared variables for applied if no subconstituent of this category is included in
unification, which makes it possible to replace only certain A1, e.g. if A1 includes no subject.
parts of the argument and to leave the rest unchanged. In addition to an exact match the generalized constituent
categories np (noun phrase) and vp (verb phrase) can be
used in the category condition, i.e. the condition is satisfied
if the constituent category C is subsumed by the generalized
category (e.g. mvp vp).
The head condition is again used to speed up the selection
of possible candidates during the transfer step. If the
applicability of a transfer rule does not depend on the head
of the phrase, then the special constant nil is used as head
condition. Another special case is the head condition notex.
In analogy to the corresponding use in the argument condition
this indicates that the rule can only be applied if A1 does not
contain a head element.
Example 4. The Japanese verbal with head SURU and Sino-
Japanese compound NINSHIKI is translated into an English
verbal with head recognize:
Figure 7. Example of English parse tree ptr(vbl, SURU /47, [hea( SURU /47), sjc( NINSHIKI /17)],
[hea(recognize/vb)]).
Example 3. The Japanese modifying verb phrase (mvp) X
NIMUKETA is translated as modifying adpositional phrase (map) A1 = [hea(SURU/47), hef(3/1), sjc(NINSHIKI/17)]
toward X. In more detail, the Japanese modifying verb phrase A2 = [hea(recognize/vb), hef(3/1)]
contains a verbal with head MUKERU and auxiliary TA and an As explained before, the order of the elements in A1 is of no
adpositional object with adposition NI: importance, the rule is applied to A1 and the additional
ctr(mvp, map, MUKERU/47, element hef(3/1) is added to the elements in Req2.
[vbl([hea(MUKERU/47),hef(6/4), aux([hea(TA),
hef(54/1)])]), aob([apo(NI/61)| X ])], Just as in the case of constituent transfer rules, also the
[apo(toward/in)| X ]). expressiveness of phrase transfer rules can be increased
significantly by using shared variables for unification.
C1(A1) = mvp([vbl([hea( MUKERU /47), hef(6/4),
aux([hea(TA), hef(54/1)])]), Example 5. The following rule states that a noun phrase with
aob([apo( NI /61), hea( MINSHU /2), suf( KA / head KOTO and a modifying verb phrase with verbal JUUYOU DE
31)])]) ARU and a subject X is translated into a noun phrase with

C2(A2) = map([apo(toward/in), hea(MINSHU/ head importance, definite determiner, and a modifying noun
2), suf(KA/31)]) phrase of X:

Journal of Digital Information Management
Volume 6 Number 4
August 2008 289

 ptr(np, KOTO/21, map_default(C, J, E, J2, E2) :-
[hea(KOTO/21), mvp([vbl([hea(DA/74, hef(55/4), remove_constituent(C, J,
aux([hea(ARU/74), hef(18/1)]), cap([hea(JUUYOU/18)])]), ArgJ, J2),
sub([apo(GA/61)| X ])])], remove_constituent(C, E,
[hea(importance/nn), det(def ), mnp([apo(of/in)| X ])]). ArgE, E2),
A1 = [hea(KOTO/21), mvp([vbl([hea(DA/74, hef(55/4), map_argument(C, ArgJ, ArgE).
aux([hea(ARU/74),hef(18/1)]), cap([hea(JUUYOU/18)])]), ...
sub([hea(AKUSESU/17), apo(GA/61), mno(Y), mvp(Z)])])]
map_argument(dob, J, E) :-
A2 = [hea(importance/nn), det(def ), mnp([apo(of/in),
hea(AKUSESU/17), mno(Y), mvp(Z)])] np_match(dob, J, E).
The variables Y, Z are used for the convenience of the reader For the default mapping of direct objects both phrases must
to shorten the example. An important point that becomes contain a subconstituent with category dob. The
obvious from the example is that the set property for the subconstituents are removed from the lists by calling the
argument condition does not only apply to the top level of A1 predicate remove_constituent. This predicate returns the
but extends recursively to any level of detail specified in Req1, argument of the removed constituent, it fails if the constituent
e.g. to the subconstituents of sub in this example. does not exist. Finally, np_match is called, which is defined
in analogy to vp_match, in order to derive transfer rules for
6. Acquisition and Consolidation the subconstituents of the two arguments.
The acquisition module traverses the Japanese and English The transfer rules that are derived by the acquisition module
parse trees and derives new transfer rules, which are added are very specific because they consider all context-dependent
to the rule base. We start the search for new rules at the translation dependencies in full detail to avoid any conflict
sentence level by calling vp_match(vp, JapSent, EngSent). with existing rules in the rule base. This guarantees correct
This predicate matches two verb phrases VPJ and VPE, the translations but leads to a huge number of complex rules,
constituent category C is required for the category condition which has negative effects on computational efficiency. It also
in the transfer rules: badly affects the coverage for unseen sentences. To avoid
this overtraining we perform a consolidation step to prune
vp_match(C, VPJ, VPE) :- the transfer rules as long as such new generalized rules are
reverse(VPJ, VPJR), not in conflict with other rules. The relaxation of rules mainly
reverse(VPE, VPER), concerns contextual translation dependencies of
vp_map(C, VPJR, VPER). adpositions, head nouns, determiners, the number feature,
The predicate first reverses the two lists so that the leftmost and verbals. The most commonly performed transformations
constituents (in the sentences) are examined first, which are:
facilitates the correct mapping of subconstituents with • to simplify a phrase transfer rule or to replace it with
identical constituent category, e.g. several modifying nouns. a word transfer rule,
It then calls the predicate vp_map, which is implemented as • to use the generalized categories np or vp in the
recursive predicate for the correct mapping of the individual
category condition,
subconstituents of VPJ:
• to split a phrase transfer rule in two simpler rules.
vp_map(_, [], []).
Figure 8 shows the transfer rules that were derived from our
... translation example. Rule 4 and Rule 10 are word transfer
vp_map(C, VPJ, VPE) :- rules that were produced by the consolidation module (the
map_dob(C, VPJ, VPE, VPJ2, VPE2), original rules are struck out and written in angle brackets).
vp_map(C, VPJ2, VPE2).
... 7. Transfer and Generation
vp_map(_, _, _). The transfer module traverses the Japanese parse tree top-
down and searches for transfer rules that can be applied.
Each rule for the predicate vp_map is responsible for the The chosen design of the transfer rules guarantees the robust
mapping of a specific Japanese subconstituent (possibly processing of the parse tree. One rule only changes certain
together with other subconstituents), e.g. map_dob looks parts of a constituent into the English equivalent, other parts
for a subconstituent with category dob in VPJ and tries to are left unchanged to be transformed by other rules during
derive a transfer rule to produce the corresponding translation subsequent processing steps. Therefore, our transfer
in VPE. All subconstituents in VPJ and VPE that are covered algorithm is able to work efficiently on a mixed Japanese-
by the new transfer rule are removed from the two lists to English parse tree, which gradually turns into a fully translated
produce VPJ2 and VPE2. In that way all subconstituents are English parse tree.
examined until the lists are empty or no more new rules can At the top level we first apply phrase transfer rules (predicate
be found. Each derived rule is added to the rule base if it is apply_ptrules) to the sentence before we try to translate each
not included yet.
constituent in the sentence individually (predicate
Each predicate of type map_dob for the mapping of the transfer_const):
individual subconstituents both covers special mappings
as well as the default treatment: transfer(JapSent, EngSent) :-
apply_ptrules(vp, JapSent, IntermediateResult),
... transfer_const(IntermediateResult, EngSent).
map_dob(_, VPJ, VPE, VPJ2, VPE2) apply_ptrules(C, JapSent, EngSent) :-
:- apply_ptr(C, JapSent, IntermediateResult),
map_default(dob, VPJ, VPE, apply_ptrules(C, IntermediateResult, EngSent).
VPJ2, VPE2). apply_ptrules(_, Sent, Sent).
...

290 Journal of Digital Information Management
Volume 6 Number 4
August 2008

 Figure 8. Example of transfer rules

The predicate apply_ptrules applies phrase transfer rules [ConstI|RestI], ConstAC2,

recursively until no further rule can be applied successfully. [ConstI|RestI2]):-
The application of a single phrase transfer rule (predicate retrieve_const(ConstAC, RestI,
apply_ptr) is divided in two steps. First, we select all rule ConstAC2, RestI2).
candidates that satisfy the category, head, and argument equal_args(ArgI, ArgAC) :-
conditions in the rule. Second, we rate each rule and choose once(unify_args(ArgI, ArgAC, ArgAC)).
the one with the highest score. The score is calculated based unify_args(ArgI, ArgAC, ArgAC2) :- %(3)
on the complexity of the argument condition. In addition, rules var(ArgAC), ArgAC2 = ArgI.
are ranked higher if: unify_args([], [], []). %(4)
• the head condition is not nil, unify_args(ArgI, [ConstArgAC | RestArgAC],
[ConstArgAC2 | RestArgAC2]) :-
• the argument condition does not depend on the once(retrieve_const(ConstArgAC, ArgI,
head, ConstArgAC2, ArgI2)),
unify_args(ArgI2, RestArgAC, RestArgAC2).
• the argument condition contains notex.
The most challenging task for selecting rule candidates is A constituent can be retrieved from the input, if the
the verification of the argument condition because this corresponding element from the argument condition can be
involves testing for set inclusion (argument condition ⊆ input) (1) directly unified or (2) if the two categories are identical
at the top level as well as recursively testing for set equality and the two arguments are equal sets. The equality of the
of arguments of subconstituents. This is achieved by using arguments is tested by retrieving the argument condition
the predicate split, which retrieves each element in the subconstituents from the input argument until either (3) a
argument condition AC from the input I (at the same time free variable as tail (i.e. |X]) or (4) the end of the list is reached.
binding free variables through unification) and returns the For the convenience of the reader we have not shown the
remaining constituents from the input as list of additional correct treatment of using notex in the argument condition,
elements Add, which are then appended to the translation of i.e. we also check that no such subconstituent is included in
the argument condition: the input.
split(I, AC, Add) :- After applying phrase transfer rules at the sentence level, the
once(split_rec(I, AC, AC, Add)). predicate transfer_const examines each individual
split_rec(Add, [], [], Add). subconstituent. It first tries to apply constituent transfer rules
split_rec(I,[ConstAC|RestAC],[ConstAC2|RestAC2], before calling a predicate trans(C, JapArg, EngArg) for the
Add):- category-specific transfer of the argument. For simple
once(retrieve_const(ConstAC, I, ConstAC2, constituents this means the application of a word transfer
I2)), rule, for complex constituents it involves again the application
split_rec(I2, RestAC, RestAC2, Add). of phrase transfer rules (apply_ptrules), the recursive call of
retrieve_const(Const,[Const|RestI],Const,RestI). %(1) the predicate transfer_const, and some post-editing, e.g.
retrieve_const(ConstAC, [ConstI|RestI], removing the theme particle from a subject.
ConstAC, RestI):-%(2) As last processing step of a translation, the generation
ConstAC =.. [Category, ArgAC], module generates the surface form of the sentence as
ConstI =.. [Category, ArgI], character string. For that purpose we traverse again the parse
equal_args(ArgI, ArgAC). tree in a top-down fashion and transform the argument of
retrieve_const(ConstAC, each complex constituent into a list of surface strings, which

Journal of Digital Information Management
Volume 6 Number 4
August 2008 291

 Figure 9. Example of user interface

is computed recursively from its subconstituents as nested and the resulting parse tree after the transfer step. Finally,
list and flattened afterwards. The correct surface forms for the user can choose a Japanese-English sentence pair and
words with irregular inflections is determined by accessing watch the details of the acquisition and consolidation
the English lexicon. process. This enables the user to correct the result of a
Since the order of the subconstituents in the argument of a translation and verify the consequences for acquisition and
complex constituent could have been arbitrarily rearranged consolidation before updating the rule base. The resulting
through the application of phrase transfer rules, the system represents a valuable tool for language learning and
generation module cannot derive the original sequence of customized machine translation.
several subconstituents with identical category (e.g. several Future work will focus on extending the coverage of the
modifying adjective phrases) from the information in the system so that we can process the full JENAAD corpus and
parse tree. However, to maintain the original sequence in perform a thorough quantitative evaluation of the translation
the translation is an important default choice in such a case. quality using tenfold cross-validation. We also plan to make
Therefore, we have added an additional processing step our system available to students of Japanese Studies at our
after parsing a Japanese source sentence in which we add university in order to receive valuable feedback from practical
a sequence number as simple constituent seq(Seq) to each use.We also have just started implementing a Web interface
argument of a complex constituent. As a consequence we using Java Server Faces with interactive features to
had to extend the transfer component so that it ignores but manipulate lexical, syntactic, and translation knowledge. For
preserves this sequence information during the application example, it will be possible to correct parse trees by simple
of transfer rules. drag-and-drop and editing actions at the Web client. After
submitting the changes, the grammar will be instantly
8. Conclusion updated. In the same way we plan to customize lexical data
In this paper we have presented JETCAT, a Japanese-English and transfer rules. The user only has to revise translation
machine translation system based on the automatic results to customize the rule base according to his personal
acquisition of transfer rules from a parallel corpus. We have preferences.
finished the implementation of the system and demonstrated We have also agreed on a new research collaboration with
the feasibility of the approach based on a small subset of Korean researchers from Korea Advanced Institute of
the JENAAD corpus. Science and Technology (KAIST) in September 2007. Due to
We also have just started implementing a Web interface the similar nature of Japanese and Korean there is a high
using Java Server Faces with interactive features to potential for a straightforward portation to Korean-English
manipulate lexical, syntactic, and translation knowledge. For machine translation. One important intended extension of
example, it will be possible to correct parse trees by simple the machine translation framework is the incorporation of
drag-and-drop and editing actions at the Web client. After ontological knowledge to improve translation quality and to
submitting the changes, the grammar will be instantly address advanced text understanding tasks such as
updated. In the same way we plan to customize lexical data question answering or summarization. Finally, the translation
and transfer rules. The user only has to revise translation knowledge shall serve as a valuable resource for ontology
results to customize the rule base according to his personal mining and refinement.
preferences.We have also developed a convenient prototype
interface to Microsoft Word (see Fig. 9 for an example References
screenshot). The user can simply click on a sentence and [1] Brockett, C. et al. (2002). English-Japanese example-
translate it. In addition, it is possible to view the token lists based machine translation using abstract linguistic
and parse trees for both source and target language, the representations. Proceedings of the COLING-2002
application sequence of transfer rules during translation, Workshop on Machine Translation in Asia.

292 Journal of Digital Information Management
Volume 6 Number 4
August 2008

[2] Brown, P. (1990). A statistical approach to machine [22] Och, F.J., Tillmann, C., Ney, H. (1999). Improved
translation, Computational Linguistics, 16 (2) 79–85. alignment models for statistical machine translation.
[3] Carl, M. (1999). Toward a model of competence for Proceedings of the Joint Conference of Empirical Methods
corpus-based machine translation. In: Hybrid approaches in Natural Language Processing and Very Large Corpora.
to machine translation, ser. IAI Working Papers. Streiter, O., 20–28.
Carl, M., & Haller, J. (Eds.). IAI. vol. 36. [23] Richardson, S. et al. (2001). Overcoming the
[4] Carl, C., Way, A. (Eds.). (2003). Recent advances in customization bottleneck using example-based MT.
example-based machine translation. Kluwer. Proceedings of the ACL Workshop on Data-driven Machine
Translation. 9–16.
[5] Furuse, O., Iida, H. (1992). Cooperation between transfer
and analysis in example-based framework, Proceedings of [24] Santorini, B. (1990). Part-of-speech tagging guidelines
the 14th International Conference on Computational for the Penn Treebank project. Technical Report MS-CIS-90-
Linguistics. 645–651. 47. Department of Computer and Information Science,
University of Pennsylvania, 3rd revision, 2nd printing.
[6] Hutchins, J. (1986). Machine translation: Past, present,
future. Chichester: Ellis Horwood. [25] Sato, S. (1991). Example-based machine translation.
Ph.D Dissertation, Kyoto University.
[7] Hutchins, J. (2001). Machine translation over 50 years.
Histoire epistémologie langage, 23 (1) 7–31. [26] Somers, H. (Ed.). (2003). Computers and translation: A
translator’s guide. Amsterdam: John Benjamins.
[8] Hutchins, J. (2003). Has machine translation improved?
Some historical comparisons, In: Proceedings of the 9th MT [27] Utiyama, M., Isahara, H. (2003). Reliable measures for
Summit. 181–188. aligning Japanese-English news articles and sentences.
Proceedings of the 41st Annual Meeting of the ACL. 72–79.
[9] Hutchins, J. (2004). Machine translation and computer-
based translation tools: What’s available and how it’s used. [28] Watanabe, T., Imamura, K., Sumita, E. (2002). Statistical
In: A new spectrum of translation studies. (p. 13–48). Bravo, machine translation based on hierarchical phrase alignment.
J.M. (Ed.). Valladolid: University of Valladolid. Proceedings of the 9th International Conference on
Theoretical and Methodological Issues in Machine
[10] Hutchins, J. (2005). Current commercial machine
Translation. 188–198.
translation systems and computer-based translation tools.
International Journal of Translation, 17 (1–2). [29] Winiwarter, W. (2005). Incremental learning of transfer
rules for customized machine translation. In: Applications
[11] Hutchins, J. (2005). Towards a definition of example-
ofdeclarative programming and knowledge management (p.
based machine translation. Proceedings of the 2nd
47–64). Seipel, U. et al. (Eds.). LNAI, vol. 3392. Berlin:
Workshop on Example-Based Machine Translation at MT
Springer-Verlag.
Summit X. Phuket, Thailand. 63–70.
[30] Yamada, K. (2002). A syntax-based statistical translation
[12] Hutchins, J., Somers, H. (1992). An introduction to
model. Ph.D Dissertation. University of Southern California.
machine translation. London: Academic Press.
[13] Imamura, K. (2001). Hierarchical phrase alignment
harmonized with parsing, In: Proceedings of the 6th Natural
Language Processing Pacific Rim Symposium. Tokyo, Biographical Note
Japan.
[14] Kaji, H., Kida, Y., Morimoto, Y. (1992). Learning translation Prof. Dr. Werner Winiwarter is the
examples from bilingual text. Proceedings of the 14th Vice Head of the Department of
International Conference on Computational Linguistics. 672– Scientific Computing, University of
678. Vienna, Austria. He received his
[15] Knight, K. (1997). Automatic knowledge acquisition for MS degree in 1990, his MA degree
machine translation. AI Magazine 18 (4) 81–96. in 1992, and his PhD degree in
1995, all from the University of
[16] Koehn, P., Och, F.J., Marcu, D. (2003). Statistical phrase-
Vienna, Austria. The main research
based translation. Proceedings of the 2003 Conference of
interest of Prof. Winiwarter is hu-
the North American Chapter of the Association for
man language technology, in
Computational Linguistics on Human Language Technology.
48–54. particular machine translation and computer-assisted
language learning. In addition, he also works on data
[17] Liu, H. (2004). MontyLingua: An end-to-end natural mining and machine learning, Semantic Web, infor-
language processor with common sense. MIT Media Lab. mation retrieval, electronic business, and education
[18] Marcu, D., Wong, W. (2002). A phrase-based, joint systems.
probability model for statistical machine translation, In:
Proceedings of the Conference on Empirical Methods in
Natural Language Processing. 133–139.
[19] Matsumoto, Y. et al. (1999). Japanese morphological
analysis system ChaSen version 2.0 manual. NAIST
Technical Report, NAIST-IS-TR99009.
[20] Nagao, M. (1984). A framework of a mechanical
translation between Japanese and English by analogy. In:
Artificial and human intelligence (p. 173–180). Elithorn, A., &
Banerji, R. (Eds.). Amsterdam: North Holland.
[21] Newton, J. (Ed.). (1992). Computers in translation: A
practical appraisal. London: Routledge.

Journal of Digital Information Management
Volume 6 Number 4
August 2008 293