OpenCog Brainwave » RelEx

Meaning-Text Theory

Linas Vepstas — Sun, 08 Nov 2009 04:58:49 +0000

During some recent reading, it struck me that a useful framework for thinking about and talking about sentence generation is the MTT or “meaning-text theory” of Igor Mel’cuk, et al Here is one readable reference:

Igor A. Mel’čuk and Alain Polguère, (1987) “A Formal Lexicon in Meaning-Text Theory”, Computational Linguistics, vol. 13, pp. 261-275.

portal.acm.org/citation.cfm?id=48160.48166
www.aclweb.org/anthology/J/J87/J87-3006.pdf

Within the context of that theory, the output of the Stanford parser is strictly at the SSynR or “surface syntactic representation” level, while, as a general rule Relex attempts to generate the DSynR or “Deep syntactic representation” structure. Some of what I’ve been trying to do with opencog is towards the “SemR” structure, as described in that paper.

The more I read about MTT, the more it seems to capture some of what we are trying to do (defacto are doing) with NLP within opencog. In particular, the MTT concept of a “lexical function” (which is not really described in that paper??) could be a particularly strong way of guaranteeing correct syntactic output for segsim, nlgen or NLGen2

– Linas Vepstas

Sentence Patterns

Linas Vepstas — Tue, 08 Sep 2009 14:54:23 +0000

I’ve recently resumed work on the question-answering chatbot, and am trying to get it to comprehend a broader range of questions and statements. The “big idea” is to create a number of “sentence patterns” that the pattern matcher can recognize and respond to. The reason this is a “big” idea is because I am trying to avoid anything algorothmic or procedural — everything is to be done by specifying OpenCog hypergraphs, and NOT by writing C++ code, or scheme code (or python code…etc). The reason for working entirely with patterns and hypergraphs, rather than with C++ or scheme, is because this puts the “knowledge” of the system into a form that AI routines can manipulate it: learning algos can learn new hypergraphs; statistical algos can gather usage information on which hypergraphs get triggered, and so on. This is all easer said than done: although I’ve eliminated a fair amount of question-answering code previously written in C++, I’ve also had to write some new scheme code. Bummer.

Patten matching is now used through-out all of the OpenCog NLP pipeline, although not in a unified manner. The Link Grammar parser uses patterns (called “disjuncts”) to determine how the words in a sentence can link to one-another, thus “parsing”, or pulling the grammatical structure out of a sentence (this paper provides an excellent overview). The RelEx dependency relation extractor applies patterns on the link-grammar output to extract syntactic relations. For example, the sentence “John threw a rock” becomes

_obj(throw, ball)
_subj(throw, John)

after RelEx gets done with it. And now, there are a dozen patterns inside of OpenCog that can pick out certain kinds of questions and statements from RelEx output, and pattern-match questions to find answers to them.

For example, the new OpenCog patterns convert “The capital of France is Paris” into

capital_of(France, Paris)

and similarly, “What is the capital of France?” into

capital_of(France,what)

Treating “what” as a variable, there is yet another pattern that matches up the form of the question to the form of the answer, thus deducing that “what” must be “Paris”.

Somewhat harder is using patterns to distinguish similar from dis-similar concepts, so that sentences like “John threw a green ball” aren’t used as answers to questions such as “Did John throw a red ball?”: the word “ball” with modifier “green” has to be detected as a different entity than the word “ball” with modifier “red”: these are two different entities (called “semes” in the code). In fact, out of laziness, I’ve punted on this one: the promotion of word-instances to “semes” is done by code, rather than by pattern matching. But soon, I hope, this will change. In the meanwhile, the README file provides a more detailed discussion.

Here are some patterns that work these days:

         John threw a green ball.
         Fred threw a red ball
         Mary threw a blue rock
         who threw a ball?
Syntax pattern match found: Fred John
         who threw a red ball?
Syntax pattern match found: Fred

         Did Fred throw a ball?
Truth query determined “yes”: throw

         Did Fred throw a red ball?
Truth query determined “yes”: throw

         The color of the book is red.
         What is the color of the book?
Triples abstraction found: red

         the cat sat on the mat
         what did the cat sit on?
Triples abstraction found: mat

And here are some that don’t yet work: “Did Fred throw a green ball?” — gets no reply, because the system can’t find an answer, and doesn’t make the common-sense leap of “can’t find answer-> answer must be no”. Another common-sense problem is illustrated by: “Did Fred throw a round ball?” — the system doesn’t know that balls are round, and simply assumes that a “round ball” is some special kind of “ball”. Oh well. There’s work to be done.

You can try out the chatbot yourself (when its up, and not broken!) on the IRC chat channel #opencog on the freenode.net chat servers.

– Linas Vepstas

proto-chatbot at last!

Linas Vepstas — Tue, 28 Apr 2009 02:22:07 +0000

Hands-on tutorials are planned for the next month or so; we’ve already had a few on PLN, and my turn is coming up, for the opencog NLP pipeline. So I thought I’d wire up a cute demo for the occasion: a rough, crude IRC chatbot, “La Cogita”. It can answer simple questions about straightforward statements. Nothing fancy … it doesn’t do any reasoning at all … but it can work off of the basic syntactic structure of English sentences to find answers. Thus, for example:

Mary ate a mango Hello linas, parsing ... linas, you made a statement: Mary ate a mango what did Mary eat? Hello linas, parsing ... linas, you asked a question: what did Mary eat? The answer to your question is: mango

Its meant to be a demo of the basic NLP pipeline within OpenCog. It takes input text, runs it throught the Link Grammar + RelEx parser, imports the results into the OpenCog atomspace, sucks in a small common-sense database, and waits for questions to be posed. The common-sense database is derived from MIT’s ConceptNet (OpenMind/CommonSense project), and so one can have interactions like the following:

cogita-bot: what is a saxophone? Hello linas, parsing ... linas, you asked a question: what is a saxophone? No answer was found to your question. hmm cogita-bot: what is an instrument? Hello linas, parsing ... linas, you asked a question: what is an instrument? The answer to your question is: woodwind r bass harmonica An_Oboe Oboe megaphone saxophone chronometer drum scale ukulele cymbal instrument Heh. Complete with assorted linguistic garbage

You get the idea. Don’t ask it anything more complicated than the above examples: it will fail to find any answer. Again, it does no reasoning at all. Its as thick as a brick. You can test-drive it at the #opencog channel on the freenode.net IRC network. Assuming its not down for development.

Next up: wire in NLGen for natural-language output, and start taking baby steps in actual reasoning. Anyway, I’m pretty excited, as this means that a lot of the basic bits&pieces are working, and I can now dive into the deep end, and start working on the hard stuff.

– Linas Vepstas

OpenCog Google-Summer-Of-Code Roundup

Ben Goertzel — Fri, 05 Sep 2008 02:55:38 +0000

This summer OpenCog was chosen by Google to participate in the Google Summer of Code project: Google funded 11 students from around the world to work on OpenCog coding projects under the supervision of experienced mentors associated with the OpenCog project, and the associated OpenBiomind project

Applying for GSoC was David Hart’s idea originally; and, David and the Singularity Institute did a lot of the work needed to make it happen — so I need to extend very hearty thanks to the both of them, as all in all it worked out wonderfully well.

There were plenty of ups and downs over the summer, but overall the GSoC projects went extremely well and a lot of fabulous work got done. Furthermore, a number of the projects are going to be continued during the fall and beyond, either via students continuing them as course or thesis projects, or via students continuing to work on them in their spare time … and in one case, via a student being funded to continue the project by a commercial organization interested in using their OpenCog work.

OpenCog is a large AI software project with hugely ambitious goals (you can’t get much more ambitious than “creating powerful AI at the human level and beyond”) and a lot of “moving parts” — and the most successful OpenCog GSoC projects seemed to be the ones that successfully split off “summer sized chunks” from the whole project, which were meaningful and important in themselves, and yet also formed part of the larger OpenCog endeavor … moving toward greater and greater general intelligence.

Should OpenCog be chosen to participate in GSoC next year, I believe the projects will take a quite different flavor because OpenCog will be more mature then: I would hope to see more 2009 OpenCog GSoC projects involving the integrated functionality of the OpenCog system. But this year OpenCog is young so the best approach was to have students work on various important pieces of the overall system, and that’s what happened, generally to quite good effect.

This page

http://opencog.org/wiki/GSoCProjects2008

contains brief summaries of the projects that were done, and links to Web pages, blogs and code repositories allowing you to dig in more detail into the work if you’re interested. Here I’ll just give an extremely high level summary.

Many of the projects were outstanding but perhaps the most dramatically successful (in my own personal view) was Filip Maric’s project (mentored by Predrag Janicic) which involved pioneering an entirely new approach to natural language parsing technology. The core parsing algorithm of the link parser, a popular open-source English parser (that is used within OpenCog’s RelEx language processing subsystem), was replaced with a novel parsing algorithm based on a Boolean satisfaction solver: and the good news is, it actually works … getting the best parses of a sentence faster than the old, standard parsing algorithm; and, most importantly, providing excellent avenues for future integration of NL parsing with semantic analysis and other aspects of language-utilizing AI systems. This work was very successful but needs a couple more months effort to be fully wrapped up and Filip will continue working on it during September and October.

Cesar Maracondes, working with Joel Pitt, made a lot of progress on porting the code of the Probabilistic Logic Networks (PLN) probabilistic reasoning system from a proprietary codebase to the open-source OpenCog codebase, resolving numerous software design issues along the way. This work was very important as PLN is a key aspect of OpenCog’s long-term AI plans. Along the way Cesar helped with porting OpenCog to MacOS.

There were two extremely successful projects involving OpenBiomind a sister project to OpenCog:

Bhavesh Sanghvi (working with Murilo Queiroz) designed and implemented a Java user interface to the OpenBiomind bioinformatics toolkit, an important step which should greatly increase the appeal of the toolkit within the biological community (not all biologists are willing to use command-line tools, no matter how powerful)
Paul Cao (working with Lucio Coelho) implemented a new machine learning technique within OpenBiomind, in which recursive feature selection is combined with OpenBiomind’s novel “model ensemble based important features analysis.” The empirical results on real bio datasets seem good. This is novel scientific research embodied in working open-source code, and should be a real asset to scientists doing biological data analysis.

Two projects dealt with improvements to OpenCog’s probabilistic program learning system: Shuo Chen (working with Moshe Looks) experimented with ways of improving the internals of the MOSES algorithms; whereas Alesis Novik (working with Nil Geissweiller) implemented an initial version of the PLEASURE algorithm, an alternative to MOSES that shares some of the latter’s code infrastructure. Both these difficult research-coding projects yielded promising though preliminary results and will be continued into the fall.

And the list goes on and on: in this short post I can’t come close to doing justice to all that was done, but please see the above page and the links in it for more details!

Costa Ciprian worked with Boris Iordanov on designing and creating a distributed version of the HypergraphDB, a persistent store for OpenCog; and Rich Jones worked with David Hart on creating a distributed web crawler suitable for massively distributed text parsing using OpenCog’s RelEx language parser.

In a different direction, Kino High Coursey (working with Andre Senna) designed and implemented a very elegant approach for interfacing between OpenCog and online simulation worlds such as OpenSim, implementing a framework using LISP to execute OpenCog-originated actions in simulation worlds. There is (conceptual and code-level) work to be done integrating this with other OpenCog work that involves OpenCog control of agents in simulated worlds, but Kino has introduced some excellent code and ideas into the project that is sure to be of value as things unfold.

Junfei Guo (working with Ben Goertzel) attacked a problem deep in the heart of OpenCog: mapping OpenCog’s unique AtomTable hypergraph knowledge representation into the more standard graph format used by the standard open-source Boost Graph Library. This opened up some important new discussions regarding the extent to which various graph algorithms (applied to the graph derived from a hypergraph) can serve as heuristic approximations to less-tractable hypergraph algorithms.

Elizabeth Dawn Alpert (working with Luke Kaiser) investigated the problem of making the link parser (used within OpenCog’s RelEx language framework) better handle ungrammatical text as seen in chats, IM, Twitter and so forth. This proved a thorny issue and the most progress was made on the level of cleaning up ungrammatical formats of individual words.

All in all, we are very grateful to Google for creating the GSoC program and including us in it.

Thanks to Google, and most of all to the students and mentors involved.

Onward!

Ben G

Mapping Wordnet, RelEx to OpenCog

Linas Vepstas — Mon, 05 May 2008 23:30:08 +0000

I spent the afternoon creating a formalized mapping from RelEx and Wordnet to OpenCog. The goal is to clean things up enough so that I can run word-sense disambiguation code with opencog itself. Now, one thing that was nagging me is that this is, in some sense, the hard-way forward — I could just download Rada Mihalcea’s WSD code from off the net, and just run that. But this misses the point: I want to have the network graph of word senses within opencog so that I can start trying to resolve senses across multiple sentences, and thus, potentially do document-level word-sense detection. So I’m pretty excited by the approach, but it sure does feel like re-inventing the wheel,. sometimes. I hope to post the spec to opencog-discuss in a few days.

Google Summer of Code

David Hart — Mon, 05 May 2008 20:36:11 +0000

Crunch time is here! Our participation in Google’s Summer of Code program has accelerated release schedules and shifted priorities. Ben is busy writing initial documentation, converting much of it from Novamente documentation. Gustavo, Senna and Linas are working to tidy OpenCog code, removing crufty and embarrassing bits and improving infrastructure and interfaces. Joel is working on the first collection of research-oriented MindAgents. You’ll hear more soon on this blog from these team members, and from GSoC students on the OpenCog Collective blog and the new list opencog-soc@googlegroups.com.

To quote Ben Goertzel’s post on opencog@googlegroups.com:

The Google Summer of Code selection process is done, and 11 proposals were chosen.

It was a really painful process to go through, as we had more than 70 applications, and at least 25-30 of them were really quite good.

The accepted proposals span a fairly wide variety of areas, and the choices were ultimately made based on a number of factors including

– clarity and completeness of the proposal
– background of the student
– readiness of the OpenCog codebase for the project
– critical-ness of the project for OpenCog

Of the 11 selected, 2 were for OpenBiomind projects, and the other 9 for OpenCog proper … including a bunch of stuff for the RelEx NLP toolkit.

There was a strong bias toward proposals dealing with improvements to OpenCog-related software components that already are moderately mature, like RelEx and MOSES.

Next year when OpenCog is more mature, if we are chosen to participate in GSoC again (as we hope, and have reason to somewhat expect), you can expect to see more explicitly, broadly, AGI-related proposals.

Anyway this list of selected projects is here for all who are curious:

OpenSim for OpenCog
by Kino High Coursey, mentored by Andre Luiz de Senna

Implementing a SAT/SMT Based Link Grammar Parser
by Filip Marić, mentored by Predrag Janicic

Bayesian and Causal Networks Inference using Indefinite Probabilities
by Cesar Augusto Cavalheiro Marcondes, mentored by Cassio Pennachin

Java GUI for OpenBiomind
by Bhavesh Sanghvi, mentored by Murilo Saraiva de Queiroz

MOSES: the Pleasure Algorithm
by Alesis Novik, mentored by Nil Geisweiller

Graph Algorithms for HyperGraphDB
by Guo Junfei, mentored by Ben Goertzel

Improved MOSES
by ChenShuo, mentored by Moshe Looks

RelEx Web Crawler and HypergraphDB Manager
by Rich Jones, mentored by David Hart

RelEx: Learning Simple Grammars
by Elizabeth Dawn Alpert, mentored by Lukasz Kaiser

Distributed HipergraphDB Version
by Costa Ciprian, mentored by Borislav Iordanov

Recursive Feature Selection for Enhancing Genetic Disease Prediction
by Paul Cao, mentored by Lucio de Souza Coelho

Many thanks to all who applied, all who agreed to help mentor … and especially to David Hart for coming up with the idea of applying for SIAI to be included as a mentoring organization in GSoC, with a focus on OpenCog work.

We’d also like to thank the terrific Open Source team at Google, particularly Leslie Hawthorn, Dave Anderson and Chris DiBona, for their patience and good advice.