digital perspective: An “image” of the universe, stored as a web of idea modules in memory.
- Each module has a name (ex: “pudding”, “joy”, “Martha Stewart”, “death”, “the word at”)
- Modules can be simple (words, ideas, memories, descriptions, prepositions, etc), sense-replicatory (see an image, hear a sound, whatever), or procedural (a list of steps to be carried out by the brain).
- Each module has pointers, which point to other modules (should there be types of pointers? labels, groups, causes, effects, definitions, similar… hmm…)
- Priority in terms of space is given to ideas used most often, which usually means pointed to most often.
- Priority of pointers due to behavioral cues, most memorable, “logical reasoning”, and stuff?
- Functions to add, modify, and merge modules.
Example Pseudocode (of a simple module):
pudding
memory340127856 (the memory of me laughing uncontrollably about pudding last year)
pudding-image (pudding-image will point to visual sensory modules; this list will also include any memories of seeing pudding; Note: this will clearly be dependent on the machine having the ability of sight)
food
dessert
pudding-taste (will similarly point to taste sensory modules)
… and more stuff, depending on what pointers are most often necessary.
Questions:
1. How will the machine organize and prioritize? Through procedural modules?
2. How will language work? Are there just many procedures for handling language?
Propose an improvement? Or let me know if something here seems completely unreasonable?
Tags: artificial intelligence, digital perspective, language, module, modules
There are two things, I think, that you need:
(1) is a physical model, a structure the pointers can be assigned to. Having “pointers” is all well and good, but you *need* a structure that handles those. Once that structure is in place, you can abstract outward to the pointer structure.
(2)You mentioned this, but it is not part of your model of pudding:
The agent (“AI device”) need to store some sort of table of things that it can do to pudding, and one of what pudding can do to it.
In other words, you need a list of functions that interact with the environment, ways you can induce a response in the pudding; and a list of things the pudding can do to you, so you can decide how to respond to the pudding.
As an example, if one of the things pudding can do to you is eat you from 20 yards away, you want your agent to be able to decide to stay at least 20 yards away (if that’s the decision that’s made) You figure this out, by looking at your table of things that can be done to you
As an aside, you need to prioritize this list… sure, your friend *can* shoot you, but when is it likely? Should it be at the “top” of your list (and thus frequently checked) or lower down?
***
In short, there’s a lot that goes into designing an intelligent agent.
My argument, I guess, is that this is all the structure one really needs for intelligent thought. I’m not saying this is the complete structure of an intelligent “agent”; in terms of physical *doing* of a robot, say, more will have to be included to account for physical movements.
For example, perhaps the input of the *sight* of pudding will lead to a procedural module that will immediately invoke some physical movements. Or perhaps it will be more voluntary, it will lead initially to a memory of being attacked by pudding first, which in turn may lead to a module that induces fear which leads to a module that induces physical movement.
I probably should have explained that I wanted to start with intelligent thought and work towards usability after the full complexity of “thought” is established. And, frankly, I understand that this isn’t how “AI” is usually done. Maybe this is called something different. I’m okay with that.
Fair enough. That’s reasonable, and I think it comes with the assumption that a physical structure is already in place, which means it works for what you need…
So both of my critiques are invalid.
In that case, with this specific model, an advanced object system would likely be the best way of representing the models. I think CLOS(http://en.wikipedia.org/wiki/Common_Lisp_Object_System) is the most comprehensive object system currently in use, although that may not be true. Either way, you’ll want a system with multiple-inheritance (i.e. the class hierarchy is a directed a-cyclic graph), as well as some form of abstract class.
This will allow more advanced and complex grouping behaviors…
Ooooh I was going to say something about graph theory but Cory beat me to saying something smart and it’s all way over my head. I’m going to remain silent.