[hltdi-l3] 2 new revisions pushed by onlysk...@gmail.com on 2014-05-15 21:03 GMT

[hltd...@googlecode.com]

2 new revisions:

Revision: c939e24b4a0e
Branch: default
Author: Michael Gasser <gas...@cs.indiana.edu>
Date: Thu May 15 18:53:03 2014 UTC
Log: Fixed way that group trees (including merged inner groups) are
figured...
http://code.google.com/p/hltdi-l3/source/detail?r=c939e24b4a0e

Revision: a475bd71d536
Branch: default
Author: Michael Gasser <gas...@cs.indiana.edu>
Date: Thu May 15 21:03:43 2014 UTC
Log: LG-LP updated in a few places.
http://code.google.com/p/hltdi-l3/source/detail?r=a475bd71d536

==============================================================================
Revision: c939e24b4a0e
Branch: default
Author: Michael Gasser <gas...@cs.indiana.edu>
Date: Thu May 15 18:53:03 2014 UTC
Log: Fixed way that group trees (including merged inner groups) are
figured (needed for projectivity constraints).
http://code.google.com/p/hltdi-l3/source/detail?r=c939e24b4a0e

Modified:
/hiiktuu.py
/hiiktuu/constraint.py
/hiiktuu/sentence.py

=======================================
--- /hiiktuu.py Wed May 14 07:28:54 2014 UTC
+++ /hiiktuu.py Thu May 15 18:53:03 2014 UTC
@@ -75,7 +75,7 @@
s.do(verbosity=verbosity)
return s

-def never_eaten_fish(trans=True, verbosity=0):
+def never_eaten_fish(verbosity=0, trans=True):
"""
Amh አሳ በልቶ አያውቅም 'he's never eaten fish'
Either parse (trans=False) or translate -> Orm: qurxummii nyaate hin
beeku.
@@ -87,6 +87,8 @@
s = hiiktuu.Sentence(raw="አሳ በልቶ አያውቅም", language=amh, target=orm,
verbosity=verbosity)
if trans:
+# s.initialize(verbosity=verbosity)
+# s.solve(verbosity=verbosity)
s.do(verbosity=verbosity)
else:
s.parse(verbosity=verbosity)
=======================================
--- /hiiktuu/constraint.py Wed May 14 07:28:54 2014 UTC
+++ /hiiktuu/constraint.py Thu May 15 18:53:03 2014 UTC
@@ -814,6 +814,7 @@
@staticmethod
def cant_precede(var1, var2, dstore=None):
"""Is the highest value that must occur in var1 >= the lowest
value that must occur in var2?"""
+# print("Can't precede {}, {}".format(var1, var2))
# Lower
if isinstance(var1, IVar):
v1 = min(var1.get_upper(dstore=dstore))
=======================================
--- /hiiktuu/sentence.py Wed May 14 07:28:54 2014 UTC
+++ /hiiktuu/sentence.py Thu May 15 18:53:03 2014 UTC
@@ -379,9 +379,9 @@
self.variables['catgnodes'],
[gn.variables['merge_cgn']
for gn in self.gnodes]))
# The set of merged gnodes used is the union of the merged gnodes
of all merging snodes
-
self.constraints.append(UnionSelection(self.variables['merged_gnodes'],
-
self.variables['merged_snodes'],
- [sn.variables['mgnodes']
for sn in self.nodes]))
+#
self.constraints.append(UnionSelection(self.variables['merged_gnodes'],
+#
self.variables['merged_snodes'],
+# [sn.variables['mgnodes']
for sn in self.nodes]))
# The set of category gnodes used is the union of the category
nodes associated with all merged snodes
self.constraints.append(UnionSelection(self.variables['catgnodes'],

self.variables['merged_snodes'],
@@ -404,7 +404,7 @@
# All snodes must have distinct category nodes
self.constraints.extend(Disjoint([sn.variables['agnodes'] for sn
in self.nodes]).constraints)
# All snodes must have distinct concrete merged nodes nodes
- self.constraints.extend(Disjoint([sn.variables['mgnodes'] for sn
in self.nodes]).constraints)
+# self.constraints.extend(Disjoint([sn.variables['mgnodes'] for sn
in self.nodes]).constraints)
# All concrete gnodes must have distinct category nodes
self.constraints.extend(Disjoint([gn.variables['merge_agn'] for gn
in self.gnodes]).constraints)
# All position constraints for snodes
@@ -446,6 +446,12 @@

selvars=[g.variables['agnodes_pos'] for g in self.groups],

seqvars=[s.variables['agnodes'] for s in self.nodes],

mainvars=[g.variables['agnodes'] for g in self.groups]))
+# # Complex union selection by groups on positions of merged gnodes
(concrete nodes that are merged with
+# # category nodes in this group) in each selected group
+#
self.constraints.append(ComplexUnionSelection(selvar=self.variables['groups'],
+#
selvars=[g.variables['agnodes_pos'] for g in self.groups],
+#
seqvars=[s.variables['mgnodes'] for s in self.nodes],
+#
mainvars=[g.variables['merged_gnodes'] for g in self.groups]))
# # Complex union selection by groups on positions of all gnodes in
each selected group
#
self.constraints.append(ComplexUnionSelection(selvar=self.variables['groups'],
#
selvars=[g.variables['gnodes_pos'] for g in self.groups],
@@ -477,18 +483,57 @@
# trees = [list(g.variables['tree'].get_value(dstore=dstore))
for g in ginsts]
return self.solver.status

+ @staticmethod
+ def make_tree(group_dict, group_i, tree):
+ if not group_dict[group_i][1]:
+ return
+ else:
+ for mgi in group_dict[group_i][1]:
+ tree.update(group_dict[mgi][0])
+ Sentence.make_tree(group_dict, mgi, tree)
+
def create_solution(self, dstore=None, verbosity=0):
"""Assuming essential variables are determined in a domain store,
make a Solution object."""
dstore = dstore or self.dstore
# Get the indices of the selected groups
groups = self.variables['groups'].get_value(dstore=dstore)
ginsts = [self.groups[g] for g in groups]
- trees = [list(g.variables['tree'].get_value(dstore=dstore)) for g
in ginsts]
- # Get the indices of the GNodes for each SNode
s2gnodes = []
for node in self.nodes:
- gnodes = node.variables['gnodes'].get_value(dstore=dstore)
+ gnodes =
list(node.variables['gnodes'].get_value(dstore=dstore))
s2gnodes.append(gnodes)
+ # Create trees for each group
+ tree_attribs = {}
+ for snindex, sg in enumerate(s2gnodes):
+ for gn in sg:
+ gnode = self.gnodes[gn]
+ gn_group = gnode.ginst.index
+ if gn_group not in tree_attribs:
+ tree_attribs[gn_group] = [[], []]
+ tree_attribs[gn_group][0].append(snindex)
+ if len(sg) == 2:
+ # Record group merger when an snode is associated with two
gnodes
+ gn0, gn1 = self.gnodes[sg[0]], self.gnodes[sg[1]]
+ group0, group1 = gn0.ginst.index, gn1.ginst.index
+ if gn0.cat:
+ # Group for gnode0 is merged with group for gnode1
+ tree_attribs[group0][1].append(group1)
+ else:
+ tree_attribs[group1][1].append(group0)
+# print("Tree attribs {}".format(tree_attribs))
+ for gindex, sn in tree_attribs.items():
+ # First store the group's own tree as a set of sn indices
+ sn.append(set(sn[0]))
+ # Next check for mergers
+ Sentence.make_tree(tree_attribs, gindex, sn[2])
+# print("Tree attribs {}".format(tree_attribs))
+ # Convert the dict to a list and sort by group indices
+ trees = list(tree_attribs.items())
+ trees.sort(key=lambda x: x[0])
+ # Just keep the snode indices in each tree
+ trees = [x[1][2] for x in trees]
+# trees = [list(g.variables['tree'].get_value(dstore=dstore)) for g
in ginsts]
+ # Get the indices of the GNodes for each SNode
self.solutions.append(Solution(self, ginsts, s2gnodes,
len(self.solutions), trees=trees))

@@ -556,9 +601,9 @@
{gn.sent_index for gn in self.sentence.gnodes if
gn.cat},
0, 1)
# Merged concrete GNodes associated with this SNode: 0 or 1
- self.svar('mgnodes', "w{}->mgn".format(self.index), set(),
- {gn.sent_index for gn in self.sentence.gnodes if not
gn.cat},
- 0, 1)
+# self.svar('mgnodes', "w{}->mgn".format(self.index), set(),
+# {gn.sent_index for gn in self.sentence.gnodes if
not gn.cat},
+# 0, 1)
# Features
features = self.get_features()
if len(features) > 1:
@@ -705,6 +750,7 @@
ngroups = len(self.sentence.groups)
nsnodes = len(self.sentence.nodes)
cand_snodes = self.sentence.covered_indices
+ print("Creating variables for {}, # abs nodes {}".format(self,
self.nanodes))
# GNode indices for this GInst (determined)
self.variables['gnodes'] =
DetVar('g{}->gnodes'.format(self.index), {gn.sent_index for gn in
self.nodes})
# Abstract GNode indices for GInst (determined)
@@ -761,7 +807,8 @@
else:
self.svar('tree', 'g{}->tree'.format(self.index),
# at least as long as the number of self's nodes
- set(), set(cand_snodes), self.ngnodes,
len(cand_snodes), ess=True)
+ set(), set(cand_snodes), self.ngnodes,
len(cand_snodes))
+#, ess=True)
# set(), set(range(nsnodes)), self.ngnodes, nsnodes,
ess=True)
# Determined variable for within-source agreement constraints,
gen: 0}
agr = self.get_agr()
@@ -977,7 +1024,7 @@
self.gnode_dict = {}
self.groups_tnodes = []
for tgroup, tgnodes, tnodes, ginst in attribs:
-# print('tgroup {}, tgnodes {}, tnodes {}, ginsts
{}'.format(tgroup, tgnodes, tnodes, ginst))
+# print('tgroup {}, tgnodes {}, tnodes {}, ginst
{}'.format(tgroup, tgnodes, tnodes, ginst))
for tgnode, tokens, feats, agrs, t_index in tgnodes:
self.gnode_dict[tgnode] = (tgroup, tokens, feats, agrs,
t_index)
self.groups_tnodes.append((tgroup, tnodes, ginst))
@@ -1036,12 +1083,19 @@
if verbosity:
print('Building {}'.format(self))
tginsts, tgnodes, trans_index = self.groups_tnodes,
self.gnode_dict, self.index
+# print("Tginsts {}, tgnodes {}, trans_index {}".format(tginsts,
tgnodes, trans_index))
# Figure out the target forms for each snode
# print('tgnodes {}'.format(tgnodes))
+ # Dictionary mapping source node indices to initial target node
indices
+ tnode_index = 0
+ node_index_map = {}
for snode, (gnodes, features) in zip(self.sentence.nodes,
self.solution.snodes):
+# print(" Snode {}, gnodes {}, features {}, tnode_index
{}".format(snode, gnodes, features, tnode_index))
if not gnodes:
# snode is not covered by any group
self.nodes.append(([snode.token], []))
+ node_index_map[snode.index] = tnode_index
+ tnode_index += 1
else:
t_indices = []
if len(gnodes) > 1:
@@ -1053,7 +1107,7 @@
# else:
# print(s.format(snode.index, gnodes[1],
gnodes[1].ginst.group, gnodes[0], gnodes[0].ginst.group))
gn0, gn1 = tgnodes[gnodes[0]], tgnodes[gnodes[1]]
-# print("gn0 {}, gn1 {}".format(gn0, gn1))
+# print(" gn0 {}, gn1 {}".format(gn0, gn1))
tgroups, tokens, targ_feats, agrs, t_index = zip(gn0,
gn1)
token = False
i = 0
@@ -1066,27 +1120,29 @@
targ_feats = Features.unify_all(targ_feats)
# Merge the agreements
agrs = Translation.combine_agrs(agrs)
- if len(tgroups[0].tokens) > 1:
- t_indices.append((tgroups[0], gn0[-1]))
- if len(tgroups[1].tokens) > 1:
- t_indices.append((tgroups[1], gn1[-1]))
+# if len(tgroups[0].tokens) > 1:
+ t_indices.append((tgroups[0], gn0[-1]))
+# if len(tgroups[1].tokens) > 1:
+ t_indices.append((tgroups[1], gn1[-1]))
## Record this node and its groups in mergers
tg = list(zip(tgroups, gnodes))
# Sort the groups by which is the "outer" group in the
merger
tg.sort(key=lambda x: x[1].cat)
tg = [x[0] for x in tg]
self.mergers.append([snode.index, tg])
+# print(' tgroups {}, token {}, t_indices
{}'.format(tgroups, token, t_indices))
else:
gnode = gnodes[0]
if gnode not in tgnodes:
+# print(' snode {} / gnode {} has no
translation'.format(snode, gnode))
continue
else:
gnode = gnodes[0]
tgroup, token, targ_feats, agrs, t_index =
tgnodes[gnode]
if len(tgroup.tokens) > 1:
t_indices.append((tgroup, t_index))
-# print('tgroup {}, token {}, t_index
{}'.format(tgroup, token, t_indices))
-
+# print(' tgroup {}, token {}, t_index
{}'.format(tgroup, token, t_indices))
+
# Make target and source features agree as required
if not targ_feats:
targ_feats = Features({})
@@ -1097,7 +1153,20 @@
gen = self.sentence.target.generate(token, targ_feats)
if verbosity > 1:
print(" Generating node form {}/{}: {}".format(token,
targ_feats, gen))
+ node_index_map[snode.index] = tnode_index
+ tnode_index += 1
self.nodes.append((gen, t_indices))
+# print("S->T index mapping {}".format(node_index_map))
+ # Fix indices in tgroup trees
+ trees = []
+ for t in self.trees:
+ tree = []
+ for src_index in t:
+ if src_index in node_index_map:
+ tree.append(node_index_map[src_index])
+ trees.append(tree)
+ self.trees = trees
+# print('Mapped tree indices {}'.format(self.trees))
# Add TNode elements
tgnode_elements = []
for ginst_i, (tginst, tnodes, ginst) in enumerate(tginsts):
@@ -1237,6 +1306,7 @@
order_vars = self.variables['order']
# for first, second in self.order_pairs:
# self.constraints.append(SetPrecedence([order_vars[first],
order_vars[second]]))
+# print("Order pairs {}".format(self.variables['order_pairs']))

self.constraints.append(PrecedenceSelection(self.variables['order_pairs'],
order_vars))
self.constraints.append(Order(order_vars))
@@ -1244,8 +1314,13 @@
## Tree constraints
for i_var, tree in zip(self.variables['tree_sindices'],
self.variables['trees']):
self.constraints.append(UnionSelection(tree, i_var,
order_vars))
+# i_var.pprint()
+# tree.pprint()
+# print("Tree union {}".format(self.constraints[-1]))
# Convexity (projectivity)
self.constraints.append(SetConvexity(tree))
+# for c in self.constraints:
+# print(c)

def realize(self, verbosity=0):
"""Run constraint satisfaction on the order and disjunction
constraints,

==============================================================================
Revision: a475bd71d536
Branch: default
Author: Michael Gasser <gas...@cs.indiana.edu>
Date: Thu May 15 21:03:43 2014 UTC
Log: LG-LP updated in a few places.
http://code.google.com/p/hltdi-l3/source/detail?r=a475bd71d536

Modified:
/paperdrafts/lglp/hltdi.bib
/paperdrafts/lglp/lglp14.pdf
/paperdrafts/lglp/lglp14.tex

=======================================
--- /paperdrafts/lglp/hltdi.bib Wed May 14 07:28:54 2014 UTC
+++ /paperdrafts/lglp/hltdi.bib Thu May 15 21:03:43 2014 UTC
@@ -316,6 +316,17 @@
year = "1990",
address = "Cambridge, MA"
}
+
+@Article{chiang,
+ author = {David Chiang},
+ title = {Hierarchical Phrase-Based Translation},
+ journal = {Computational Linguistics},
+ year = {2007},
+ volume = {33},
+ number = {2},
+ pages = {201--228},
+ annote = {}
+}

@BOOK{chomsky:aspects,
AUTHOR = "Noam Chomsky",
=======================================
--- /paperdrafts/lglp/lglp14.pdf Wed May 14 07:28:54 2014 UTC
+++ /paperdrafts/lglp/lglp14.pdf Thu May 15 21:03:43 2014 UTC
Binary file, no diff available.
=======================================
--- /paperdrafts/lglp/lglp14.tex Thu May 15 06:40:33 2014 UTC
+++ /paperdrafts/lglp/lglp14.tex Thu May 15 21:03:43 2014 UTC
@@ -48,16 +48,16 @@
\title{Minimal Dependency Grammar for Machine Translation}

\author{
-% First Author \\
-% Affiliation / Address line 1 \\
-% Affiliation / Address line 2 \\
-% Affiliation / Address line 3 \\
-% {\tt email@domain} \\\And
-% Second Author \\
-% Affiliation / Address line 1 \\
-% Affiliation / Address line 2 \\
-% Affiliation / Address line 3 \\
-% {\tt email@domain} \\
+% Michael Gasser \\
+% School of Informatics and Computing \\
+% Indiana University \\
+% Bloomington, IN, USA \\
+% {\tt gas...@indiana.edu} \\\And
+% Alex Rudnick \\
+% School of Informatics and Computing \\
+% Indiana University \\
+% Bloomington, IN, USA \\
+% {\tt al...@indiana.edu} \\
}

\date{}
@@ -70,10 +70,11 @@
an ongoing project to develop a framework and a set
of tools for the creation of simple bilingual dependency grammars for
machine translation
and computer-assisted translation into and out of under-resourced
languages.
-The basic units in Hiiktuu, called \textbf{groups}, are headed multi-item
sequences,
+The basic units in Hiiktuu, called \textbf{groups}, are headed multi-item
sequences.
%% AJR: Could this be reworded? Or maybe something like "which correspond
to
% \textit{catenae} from the dependency grammar literature" ...
-technically corresponding to catenae in dependency trees.
+% MG: Think I'll leave it out of the abstract.
+% technically corresponding to catenae in dependency trees.
In their simplest form, group positions consist of wordforms.
More abstract groups, generalizing across multiple sequences of specific
word forms,
contain lexemes, syntactic categories, and grammatical features.
@@ -154,8 +155,8 @@
linguistic resources correlates with a lack of written material in the
language, and
we would like to develop tools to aid human translators, including
non-professional ones,
in translating documents into these languages.
-%% AJR: maybe "non-linguist" rather than naive? ...
-Our long-term goal is a system that allows naive users to write bilingual
lexicon-grammars
+Our long-term goal is a system that allows users with little or no
linguistic experience
+to write bilingual lexicon-grammars
for low-resource languages that can also be updated on the basis of
monolingual and bilingual corpora,
to the extent these are available, and that can be easily integrated into
a CAT system.

@@ -202,14 +203,14 @@

A catena has a head, and each Hiiktuu group must also have a head, the
main function of which is to
index the group within the lexicon.
-A group's entry may also specify translations to groups in one or more
other languages,
-and as in the phrase tables of PBSMT systems.
+A group's entry may also specify translations to groups in one or more
other languages.
For each translation, the group's entry gives an \textbf{alignment}
between the groups, representing correspondences between
-group elements, again as in PBSMT.
+group elements, as in the phrase tables of phrase-based SMT.
Entry~\ref{entry:end} shows a simple group entry of this sort.
The English group \textit{the end of the world} with head \textit{end} has
as its Spanish translation
the group \textit{el fin del mundo} (which must have an entry in the
Spanish lexicon).
-In the alignment, all but the fourth word (\textit{the}) in the English
group is associated with a word in the Spanish group.
+In the alignment, each word other than the fourth word (\textit{the}) in
the English group is associated with the position
+of a word in the Spanish group.

\begin{entry}
%\begin{spacing}{.85}
@@ -407,13 +408,13 @@
this stage.}
The forms resulting from this first pass are then used to look up
candidate groups in the
group dictionary.
-Next the system assigns a set of groups so the input sentence, effectively
chunking the sentence.
+Next the system assigns a set of groups to the input sentence, effectively
chunking the sentence.
A successful group assignment satisfies several constraints: (1)~each word
in the input sentence
must be assigned to zero, one, or, in the case of node merging, two group
elements.
(2)~Each element in a selected group must be assigned to one word in the
sentence.
(3)~For each selected group, within-group agreement restrictions are
satisfied.
(4)~For each category element in a selected group, it is merged with a
non-category element in another
-selected group.
+selected group (see the two examples in Figure~\ref{fig:mind}).
Analysis is a robust process; some words in the input sentence may end up
unassigned to any group.

Analysis is implemented in the form of constraint satisfaction, making use
of a number of the insights
@@ -422,7 +423,7 @@
incorporate context, ambiguity is still possible, particularly in the
context of figurative expressions
that also have a literal interpretation.
In this case, the constraint satisfaction process undertakes a search
through the space of possible group
-assignments, creating an analysis for successful assignment.
+assignments, creating an analysis for each successful assignment.
Again this process relies on notions from XDG.

During the transfer phase, a source-language group assignment is converted
to an assignment of target-language
@@ -432,12 +433,20 @@
For example, it is during this stage in the translation of the English
sentence \textit{the mayor passes the buck}
to Spanish that the Spanish verb assigned to the head of the group
\textit{escurrir el bulto} would be
assigned the tense (\textit{tiempo}), person and number features
\texttt{tmp=prs, prs=3, num=1}.
+As with within-source ambiguity, some cross-language ambiguity is
eliminated because it is multi-word units
+that are being translated, but a source-language group may still have more
than one translation.
+The transfer phase creates a separate target-language group assignment for
each combination of translations of the
+source-language groups.

-During the realization phase, target-language surface forms are generated.
+During the realization phase, for each target-language group assignment,
+target-language surface forms are generated based on the lexemes and
grammatical features that resulted from
+the transfer phase.
In the current version of the system, this is accomplished through a
dictionary that maps
-roots and feature sets to surface forms.
-In a future version, it will be possible to call a morphological generator
at this stage.
-Finally, target-language words are sequenced in a way that satisfies
conditions in target-language groups.
+lexemes and feature sets to surface forms.
+In a future version, it will be possible to call a dedicated morphological
generator at this stage.
+Finally, target-language words are sequenced in a way that satisfies
word-order
+conditions in target-language groups.
+The sequencing process is implemented with constraint satisfaction.

\section{Related work}
\label{sect:related}
@@ -467,6 +476,10 @@
mentioning which theories it has the most in common with.
Like Construction Grammar \cite{steels} and Frame Semantics
\cite{fillmoreFS},
it treats linguistic knowledge as essentially phrasal.
+Like synchronous context-free grammar (SCFG) \cite{chiang}, it associates
multi-word units in
+two languages, aligning the elements of the units and representing word
order within each.
+Hiiktuu differs from SCFG in having nothing like rewrite rules or
non-terminals.
+
Hiiktuu belongs to the family of dependency grammar (DG) theories because
the heads of its
phrasal units are words or lexemes rather than non-terminals.
It has the most in common with those computational DG theories that parse
sentences using
@@ -480,7 +493,7 @@

Finally, though we have not yet looked into the details,
the theory's relative simplicity and flexibility should allow it to be
converted
-to other more elaborate formalisms, for example, synchronous context-free
grammars.
+to other more elaborate formalisms, for example, SCFG.

\section{Status of project, ongoing and future work}
\label{sect:status}
@@ -491,14 +504,20 @@
under the GPL license.
To date, we have only tested the framework on a limited number of
Amharic-to-Oromo
translations.
-In order to develop a more complete lexicon/grammar for this language pair
and others,
+In order to develop a more complete lexicon-grammar for this language pair
and others,
we are currently working on methods for automatically extracting groups
from
dictionaries in various formats and from the limited bilingual data that
are available.
+As a part of this work, it will be crucial to determine whether,
+it is simpler to extract Hiiktuu groups from data than to extract
+grammars of other sorts, for example, SCFG.
We are also implementing a GUI that will allow naive bilingual users to
create Hiiktuu entries.
-For the longer term, our goal is tools for intelligent elicitation of
lexical entries
-[ref to nirenburg].
+Again we will want to evaluate the framework with respect to the simplicity
+of entry creation.
+For the longer term, our goal is tools for the intelligent elicitation of
lexical entries;
+for example, when two entries resemble one another, users could be queried
about the
+value of collapsing them into a more abstract entry.

As far as the grammatical framework is concerned, as noted above,
the lack of dependencies between the heads of groups leaves the system
@@ -516,12 +535,12 @@
\label{sect:conclusions}

Relatively sophisticated computational grammars, parsers, and/or generators
-exist for perhaps a dozen languages, and usable machine translation
systems exist for
+exist for perhaps a dozen languages, and usable MT systems exist for
at most dozens of pairs of languages.
This leaves the great majority of languages and the communities who speak
them
relatively even more disadvantaged than they were before the digital
revolution.
What is called for are methods that can be quickly and easily deployed to
-begin to record the grammars and lexical of these languages and to use
these
+begin to record the grammars and lexica of these languages and to use these
tools for the benefit of the linguistic communities, in part to aid in the
translation
of documents into the languages.

@@ -529,10 +548,6 @@
Though far from achieving our ultimate goals, we have developed a simple,
flexible, and robust
framework for bilingual lexicon-grammars and MT/CAT that we hope will be a
starting
point for a large number of under-resourced languages.
-
-% include your own bib file like this:
-%\bibliographystyle{acl}
-%\bibliography{acl2014}

\bibliographystyle{acl}
\bibliography{hltdi}