Re: Runtime "learning"

"Quinn Tyler Jackson" <qjackson@home.com> wrote in message news:01-10-140...
> > However, I would like to build a parser which learns the grammar of
> > the IDL-like language at runtime. In other words, I want it to read
> > some templates of some kind, and then recognize sentences conforming
> > to the language described in those templates. In this way, when
> > updating the language, the parser doesn't need to be compiled again.
>
> A few links that might get you started:
>
> http://www.cse.iitk.ac.in/research/mtech1998/9811115/index.html
> http://sequence.rutgers.edu/~nevill/ (Projects - Sequitur)
>
> The above two examples are not template, but instance based.
>
> On the theoretical end, some of the literature on adaptive grammar cited here:
>
> http://QuinnTylerJackson.n3.net/computer_science/literature_review.html
>
> (In particular, the work of Christiansen, Burshteyn, Boullier, and Shutt.)
>
> An upcoming paper (Jackson & Langan - "Adaptive Predicates in
> Empty-Start Natural Language Parsing") covers some of the issues of
> template based modification, but in the context of NLP. Abstract: "We
> examine the usefulness of the §-Calculus as a formalism for natural
> language parsing, and in particular the power of a single adaptive
> predicate in a structure-only English grammar in providing document
> wide context resolution. We were able to construct an §-grammar for a
> limited subset of English that a) contained no English words at start,
> and b) correctly parsed a series of twenty-two sentences without the
> use of any mechanism outside the formalism of the §-grammar itself."
>
> Very few out-of-the-box parsers can modify the grammar proper on the
> fly in the way you're describing. (For a very small value for "very
> few.") A commercial-scale PG that allows just that is "coming soon"
> however. (Implemented - not fully documented.)


One of my projects is a full object implementation of a parser that
contains the BNF of the language as a fully writable property. When
this is changed the parse shall be incrementally changed. It appears
to me that objects and lazy or delayed evaluation makes the old dream
of the so-called compiler-compiler (NOT yacc) a reality, for the
original compiler-compilers were overly batch oriented, and redid too
many things to change the BNF.


On a related note, the United States government is currently asking
for proposals in detecting terrorist activity; see article in the Week
in Review section of the New York Times for Oct 28th.


One of the requests described in the article is for software able to
detect mixed languages, including Pashto and other languages of South
Asia, in a document such as an email, and to adapt the parsing
accordingly.


Of course, in terms of the structure of cs fiefdoms, NLP seems fully
divergent from BNF and formal language parsing. This may be part of
the problem set for NLP does not appear to have many usable results,
and one area that MAY be unexplored is the applicability of formal
methods to a large amount of actual communication, which uses simple
grammar.
[There were compilers 25 years ago that could change the language they
parse on the fly by adding BNF. This is not a new problem. -John]

Return to the comp.compilers page.
Search the comp.compilers archives again.