A text-based and spoken language processing framework based on the Constraint Dependency Grammar (CDG) developed by Maruyama [24, 25] is discussed. The scope of CDG is expanded to allow for the analysis of sentences containing lexically ambiguous words, to allow feature analysis in constraints, and to efficiently process multiple sentence candidates that are likely to arise in spoken language processing. The benefits of the CDG parsing approach are summarized. Additionally, the development of CDG grammars using our grammar tools and parser is discussed.

In this paper, we describe a system which is capable of utilizing a variety of knowledge sources to select the most appropriate parse for a spoken sentence. These knowledge sources include syntax, semantics, and contextual information. We discuss one way to utilize contextual information when determining the parse for a sentence. At its simplest level, the system can be thought of as a generalpurpose query answering system for multiple topical databases. The user's input would be processed by the language processor which interfaces to the databases with the goal of interacting with the correct database in order to provide a reasonable answer to the user's spoken request. Initially, it analyzes a word graph of sentence hypotheses provided by a speech recognizer using general syntactic and semantic rules. Then, if the utterance is still ambiguous, it utilizes contextspecific constraints to further refine the analysis. This brings us closer to developing a more general purpose interface f...

This paper describes the parallelization of Constraint Dependency Grammar (CDG) parsing. Though CDG provides a flexible framework for text-based and spoken language parsing and has an expressivity strictly greater than context-free grammars (CFGs), it also has a relatively slow serial running time (i.e., O(n 4 )). However, a parallelization for this algorithm is derived which uses O(n 4 ) processors to parse in O(k) time for a CRCW P-RAM, where n is the number of words in the sentence and k, the number of constraints, is a grammatical constant. Additionally, the paper describes an implementation of the algorithm on the MasPar MP-1, which uses the special features of the machine (particularly the global router) and O(n 4 ) processors to obtain an O(k + log(n)) running time. Because the average length of an English sentence is on the order of 10 words, the MasPar MP-1 has sufficient processors (i.e., 16,000) for parsing a typical sentence. Previous work in parallel parsing has fo...

The question of how to integrate language models with speech recognition systems is becoming more important as speech recognition technology matures. For the purposes of this paper, we have classified the level of integration of current and past approaches into three categories: tightly-coupled, loosely-coupled, or semicoupled systems. We then argue that loose coupling is more appropriate given the current state of the art and given that it allows one to measure more precisely which components of the language model are most important. We will detail how the speech component in our approach interacts with the language model and discuss why we chose our language model. 1 Introduction State of the art speech recognition systems achieve high recognition accuracies only on tasks that have low perplexities. The perplexity of a task is, roughly speaking, the average number of choices at any decision point. The perplexity of a task is at a minimum when the true language model is known and co...

This paper presents an FPGA-based implementation of a co-processing unit able to parse context-free grammars of real-life sizes. The application fields of such a parser range from programming languages syntactic analysis to very demanding Natural Language Applications where parsing speed is an important issue.

We have extended Maruyama's [5, 6, 7] constraint dependency grammar (CDG) to process a lattice or graph of sentence hypotheses instead of separate text strings. A post-processor to a speech recognizer producing N-best hypotheses generates the word graph representation, which is then augmented with information required for parsing. We will summarize the CDG parsing algorithm and then describe how the algorithm is extended to process a word graph on a single processor machine. 1 Introduction The most successful of the current speech recognition systems which process continuous speech for a limited (1000 word) vocabulary are those which utilize hidden Markov models (HMM). Most systems utilizing this approach (e.g., [4, 10])) have reduced recognition errors by incorporating some language information (syntactic and semantic) directly into the HMM to reduce perplexity, but since the goal of these systems is recognition, not understanding, no structural analysis of the utterance is construc...

This paper describes the implementation of the PARSEC 1 chip, a vector processing element (PE) for parsing languages. This chip has applications not only in natural language processing, but can also be applied to other constraint satisfaction problems. The PARSEC chip is based on a parsing algorithm which formerly ran in real time on a massively parallel machine [8]; however, the chip can achieve processing speeds fast enough for real-time language processing systems, while at the same time, having a price and form suitable for mass market applications. A key component of any natural language interface is its parsing algorithm. Because some features of English (e.g., context) are clumsy or impossible to handle using existing parsers, we have extended and implemented a parsing algorithm based on a new, flexible grammatical formalism, called Constraint Dependency Grammar (CDG), introduced by Maruyama [11, 12, 13]. Although CDG has proven effective for processing English [6, 20] ...

. From a biological point of view automata arrays have been employed by John von Neumann in order to solve the logical problem of nontrivial selfreproduction. From a computer scientific point of view they are a model for massively parallel computing systems. Here we are dealing with automata arrays as acceptors for formal languages. Our focus of investigations concerns their capabilities to accept the classical linguistic languages. While there are simple relations to the regular and context-sensitive ones here we shed some light on the relations to the context-free languages and some of their important subfamilies. CR Subject Classification (1998): F.1, F.4.3, B.6.1, E.1 1 E-mail: kutrib@informatik.uni-giessen.de Copyright c fl 1999 by the author 1 Introduction One of the cornerstones in the theory of automata arrays is the early result of John von Neumann who solved the logical problem of nontrivial self-reproduction. From this biological point of view he employed a mathematica...

This paper describes the implementation of a constraint-based parser, PARSEC (Parallel ARchitecture SEntence Constrainer), which has the required flexibility that a user may easily construct a custom grammar and test it. Once the user designs grammar parameters, constraints, and a lexicon, our system checks them for consistency and creates a parser for the grammar. The parser has an X-windows interface that allows a user to view the state of a parse of a sentence, test new constraints, and dump the constraint network to a file. The parser has an option to perform the computationally expensive constraint propagation steps on the MasPar MP-1. Stream and socket communication was used to interface the MasPar constraint parser with a standard X-windows interface on our Sun Sparcstation

This paper presents an FPGA-based implementation of a syntactic parser that can process languages generated by real-life unrestricted context-free grammars (CFGs). More precisely, we study the advantages offered by a hardware implementation of a parallel version of a chart parsing algorithm adapted for word lattice parsing with unrestricted CFGs. Natural Language Processing applications, for which parsing speed is an important issue, may benefit from such an implementation. The parsing algorithm and the hardware design are first described. Then a method called tiling, based on the decomposition of processor tasks into subtasks of predefined size, is proposed. This method allows a processor and I/O bandwidth load that optimally takes into account the data-dependencies associated with the parsing algorithm. Finally, an evaluation of the design performance on real world data is presented.