Thanks.

Regarding what to learn, the system will be motivated to fill gaps in linguistic knowledge, both vocabulary mapping (e.g. WordNet synsets to OpenCyc concepts) and grammar constructions. Furthermore, acquired knowledge will be vetted with a heuristically determined number of other users.

===========

I am writing the dialog system from the lower level nodes upwards to the highest level node, in order to begin coordinated testing as soon as possible. I discovered while writing the console chat Java class that the java.io.Console instance is not always available, e.g. during a NetBeans debugging session. Therefore I altered the design to accomodate a GUI (window) in which the text chat dialog can occur. The system will initialize automatically to either the command-line console or the GUI console as the bottom node that interacts with the real world. I also changed the ‘performative’ sensation to ’speech act’.

Since humans are environment sensing organisms, our vocabulary is rooted in mainly visual terms and kinetic terms. The simply phrase ‘See spot run.’ is immediately understandable as a child where as
‘Sort this list of names alphabetically’ takes a more advanced hold of the language (ie: the child needs to be able to read/write and understand more abstract concepts).

For an electronic intelligence, this situation is reversed. For such a system, ‘See spot run.’ is an incredibly abstract and difficult concept, and requires at the very least an operational and complex visual subsystem in order to differentiate it from any other abstract real-world concept.

My argument is that as we teach children language based on visual and kinetic clues rather than the philosophical inconsistencies in Kant’s works, we should teach vocabulary to AI ‘children’ in terms that are more tangible to them, such as code, logic, and mathematics.

Furthermore a simplified vocabulary should be much simpler to teach, even if to us this vocabulary is far from simple.

Banned vocabulary: Emotions, real world objects (besides the user), sensations, kinetic and visual references, and most adjectives and adverbs.

This would decimate the available vocabulary, and lead to a more sane knowledge base, but would unfortunately prevent training by Instant Messenger and unspecialized humans.

Although I understand your point about restricting word categories such as adjectives and adverbs, I believe that Fluid Construction Grammar and the knowledge base terms readily accomodate them. In Cyc, the convention is to represent these modifiers as class membership. For example a red object is an object that is a member of the class of red-colored things. A fast activity is an activity that is a member of the class of those activities that progress in a fast manner.

The bootstrap dialog system has as two ultimate goals (1) the acquistion of broad coverage of English vocabulary and grammar, and (2) the aquisition of skills, especially programming skills so that its behavior can be improved without further recourse to programming it in Java.
-Steve

I have carefully studied your site and here are my thoughts. I did not yet check FCG and Double R materials.

About me. I am software developer (10 years of Java experience) with pure math education and last 10-15 years I devote a lot of my free time to NLP and deep NLP understanding.

Overall, I am moving in exactly the same direction as you: my main area of interest are intelligent chat-bots with precise deep NL understanding, and automatic program analysis and synthesis.

I did a project similar to yours and reached similar results. That is, I used a simple use-case (4 lines of English) and successfully parsed it into logical propositions. I used a custom-built parser with custom grammar formalism, and a toy grammar. You have moved a lot further: you use a good formalism for parsing/generation, and a good grammar formalism as a starting point.

OK, we achieved that

What I find complex are further stages. I did not find any thoughts or details on these on your site.

Some examples of hard tasks are:
- Learning unknown grammar rules
- Learning unknown words
- Resolving word sense ambiguities
- Resolving co-reference ambiguities
- Handling ungrammatical input (imagine parsing javadocs as a use case)

What mechanisms do you want to employ in these areas?

I’ll share my use case which my system used. My ultimate goal for the first stage was to create an automatic programmer who would be capable of parsing the following specification, and capable to emit a Java program that implements this specification. The specification was:

Write a TCP echo server. (Client connects to the server, sends bytes to the server, and receives them back immediately, until client does disconnect on behalf of its own). Server must be able to serve more than one client simultaneously. The server should be implemented in Java.

My system, as I said, is able to parse this text into a set of logical predicates. It accomplishes this using a toy grammar and a toy set of verb frame predicates. (I used OpenCyc as a predicate storage, but I haven’t used its commonsense reasoning except for querying the predicate extent and things hierarchy queries.) I have some screenshots of my system’s internal structures and results, if you want.

Now I am stuck with further development. I expected to find some future directions on your site, but failed.

Here are the reasons why my system can’t move:

- I find it difficult to cope with ambiguities. I don’t really know how to reason about them.
- I don’t know how to represent programs and programming domain knowledge. This applies even to synthesis.
- I find it difficult to cope with ungrammatical input.

Actually my system is just my personal toy, not affiliated with anyone. And I would like to join forces since we try to reach exactly the same goal, and I like your approach.

One another thing that I would like to ask:
What place for (a) AGI in general and (b) Novamente/OpenCog-like AGI do you see in the TexAI architecture? I guess AGI will be necessary for language understanding, acquisition, automatic programming, bootstrapping, wikipedia parsing — nearly for any of the ultimate TexAI goals.

Evgenii Philippov

Thanks for commenting on my web site. Assuming that you do not mind, I am going to post your message as a comment on my blog to which I will reply as follows:

First, given that our approach to creating artificial intelligence is indeed very similar, I suggest that you study Fluid Construction Grammar, and Double R Theory. Tomorrow I give a talk at Cycorp about these two topics, and my partially completed presentation is stored in the Texai project code repository at http://texai.svn.sourceforge.net/viewvc/*checkout*/texai/IncrementalFCG/doc/Incremental%20Fluid%20Construction%20Grammar.ppt

> Learning unknown grammar rules

The dialog system will learn unknown grammar rules by being taught by a human teacher. I will develop knowledge acquisition scripts for this purpose. I will not use a statistical approach because I want precise understanding.

> Learning unknown words

The published Texai lexicon is already very large, thus it is likely that the dialog system will be able to find existing word forms. However, only about 11,000 word senses are mapped to concepts in the knowledge base. The dialog system will have knowledge acquisition scripts that allow the human teacher to map previously unmapped words to the knowledge base. While at Cycorp I wrote a workflow tool for mapping WordNet word senses to Cyc terms, and I have a good idea what behavior is required from the system.

> Resolving word sense ambiguities
> Resolving co-reference ambiguities

I will use the theory of Walter Kintsch named Construction/Integration. In this theory, all the possible interpretations of an utterance are put into a connected network in which the nodes are the individual propositions and in which the nodes are linked if they share concept terms. Spreading activation is employed to prune out all but the most strongly stimulated interpretation. I have written a Java module that duplicates his book example, and I am eager to see if this works. Unfortunately, there are no other parsers that use this technique.

> Handling ungrammatical input (imagine parsing javadocs as a use case)

Construction grammar has the feature that any syntax unit can be a construction. If I can understand a Javadoc comment, then I should be able to describe a construction rule for it. I think that constructions can be generalized to accommodate non-text elements such as layout and icons.

> My ultimate goal for the first stage was to create an automatic programmer who would be capable of parsing the following specification, and capable to emit a Java program that implements this specification …

I also want my bootstrap dialog system to acquire programming skills. Regarding your use case I expect that your system should have an adequate commonsense understanding of the application domain, and relevant domain algorithms:

* TCP socket protocol
* Client/Server paradigm
* multithreading, including thread safety
* what “echo” means

It should have an understanding of the generally applicable programming algorithms that are relevant:

* object-oriented program classes and instances
* variable typing
* statement sequencing and control
* method definition and invocation
* program composition (e.g. initialization, process, finalization, and exception handling)
* test case generation
* programming safety (i.e. be Friendly and do not cause the host to crash)

And it should understand the relevant Java concepts:

* how to compose a Java class
* how to map attributes of domain objects to Java instance variables
* how to compose Java statements
* how to use applicable class libraries
* how to compile and execute a Java program

If the Texai dialog system were applied to your use case, then I expect a great deal of the effort would be to acquire the background algorithm knowledge from human teachers. Furthermore, I think that the specified program would be developed during a dialog with the teacher. It would only be after the system has adequately learned the subject, that it could program automatically from text specifications.

> What place for (a) AGI in general and (b) Novamente/OpenCog-like AGI do you see in the TexAI architecture?

I wish to create Artifical General Intelligence, and am building the bootstrap dialog system to achieve it ultimately using a multitude of volunteers to teach it. This is in constrast to building an intelligent chatbot for its own sake, and therefore requiring AGI because that is what’s needed.

OpenCog and Novemente are closer to raw perceptions than my own work. I believe that my approach, at a higher level of abstraction, can achieve recursive self-improvement faster than beginning with low level sensations and pattern recognition. I am using the Albus Hierarchical Control System architecture because my system will ultimately have interaction with, and have its concepts grounded in, the real world.

Cheers.
-Steve