Russel Said:
*"Oh, I can figure out how to solve most specific problems. From an AGI
point of view, however, that leaves the question of how those individual
solutions are going to serve as sources of knowledge for a system, rather
than separate specific programs. My answer is to build something that can
reason about code, for which formal logic is a necessary ingredient. If you
can figure out another way to do it, I'm all ears!"
*Well, there are at least two problems here. *1) How to gain initial
knowledge 2) How to use knowledge to achieve goals once we have it.
*
*1) How to gain initial knowledge*
Ah, this is something very cool that I've been working on lately. Pick a
particular example of initial knowledge from the example below and we can
trace how it is learned and how such learning mechanisms can be implemented.
There are many, so I'm not going to try to list them. I thought it would
also be more fun for you all to pick one and surprise me.
*Let's start with a simple example of 2 (using knowledge we already have and
learning more) : Creating a Hello World program*
Note that many of the details in how the reasoning is done are left out
because 1) they are yet to be determined in detail and 2) the email is long
enough without them.
*Initial Assumptions: *
The agent has some initial knowledge about programs, where one might find
information about programming. The agent might have a text book on it. The
agent understands what a hello world program is supposed to do.
So, what are we solving for if the agent has so many initial capabilities?
We're trying to show how the agent reasons about what it already knows to
achieve a goal.
The goal is to create a program that says "hello world". The agent
understands this by reasons about statements made in a textbook about the
"hello world" example program.
The agent has to plan its actions to achieve the intention "write a hello
world program". The plan is not a complete step by step plan. It just tells
the general direction to go. This is the rough to fine heuristic that human
beings often use. From there, does mean's ends analysis, searches for and
finds information that might be relevant to the situation at hand, and
reasons about what they've done in the past that have help achieve parts of
such a goal.
The AGI knows that programs can be created through the visual studio's IDE,
based on reading about programming in C# (the book he/she has). So, it
realizes that it needs to achieve a subgoal of finding visual studio's IDE
to use it. It knows it can do this by getting to the computer and clicking
on the icon that it knows is associated with visual studio.
The program comes up. So, then we ask ourselves "what's the next step?". Our
brain has marked memories associated with creating programs. It has recorded
the fact that we clicked on the file menu to create a new program and that
this was part of the process in achieving the goal. So, our memory pulls
this fact and executes the action because we have no reasons to not pursue
the action in memory. So, to this we go to the file menu and click "create
a new project". We also pull in relevant information, which says you have to
do <this that and the other> also if we want to create a program. We pull in
relevant info from what we read in the text book about what to be careful of
and what has to be done, etc.
What's next? We want to make the program print out "hello world". we recall
that we can do this by using the command "Console.WriteLine("")". and we
recall that the thing printed out was in between the parantheses like so:
Console.WriteLine("something to print out");
So, we hypothesize that if replace what was printed out with "hello world"
that it will work.
so we try Console.WriteLine("hello world"). it works! hurray. toda. done.
Yeah, I know. It's over simplified. But you can see the types of reasoning
that are required to achieve such a task. Do this thought experiment on
enough problems and generalize what it takes to achieve them (don't try to
overgeneralize though!).
DO NOT THROW OUT the requirements. You cannot throw out computer vision
because you don't know how to implement it. Sensory perception is a
requirement for AGI for many reasons. So, just make it an assumption in your
design until you can work out the details. We'll do the same thought
experiment on computer vision as well to see how it can be integrated with
the whole system. For now though, we're just focusing on this simple
programming task.
*
*
-------------------------------------------
AGI
Archives: https://www.listbox.com/member/archive/303/=now
RSS Feed: https://www.listbox.com/member/archive/rss/303/8660244-d750797a
Modify Your Subscription:
https://www.listbox.com/member/?member_id=8660244&id_secret=8660244-6e7fb59c
Powered by Listbox: http://www.listbox.com
