Knowledge Gathering

[sikefield3]

Hello, I want to address here somewhat high level thoughts about learning. I hope this is at least somewhat relevant for the consideration what to do between perception and action.

The IRC chat allows the agent to interact with a non-deterministic system and in this sense, it vaguely resembles the real world ?

So, what is a preferable way to acquire knowledge in such an environment ? If we let the agent interact with any kind of environment, it forms hypotheses and then tests these hypotheses by using some kind of reward (or motivational) function (or any other similar mechanism).
Hence, over time, the agent gathers an ever increasing pile of information and so its behavior becomes more successful with respect to the reward function. Now can we correctly describe this information as knowledge. Maybe another (fundamentally different agent) might gather a complete different pile of hypotheses in the same environment, at least if the world resembles out natural world.
Hmm, I think this leads us to Occam's Razor...

PS: I added this just because I stumbled on this just now: Is it possible and or desirable to simulate delayed gratification ?

[linas]

Right now, there is no complete theory to govern any of the code here. This is more of an experimental playground, to see what it might take to construct a system to work in a certain way. So far, I've exposed two major issues that I don't have a good solution for.

The design is not meant to "vaguely resemble" the real world; it is meant to actually handle that actual real world, as it really is, in full glory and detail. In that, I think it succeeds. To see this, though, you have to abstract out the question of "what is the real world?" and "how does one interact with it?" and do so in a coherent manner so that it can be described via programming and mathematical terminology, and not just vague hand-waving. Hand-waving is easy. Making it concrete, making it work, is hard.

As to "acquiring knowledge": there is a huge amount of material at https://github.com/opencog/learn that describes one way of doing this. Of course, deep learning and LLM's is another, and there are also several other techniques. For example, random forests fail to scale simply and easily to large GPU clusters, but otherwise "work well", if you ignore the scaling problem. opencog/learn has a different set of scaling issues: No one is trying to figure out how to backprop it, or get it to run on GPU's.

None of the stuff in "learn" is based on "maximizing reward". Its all based on maximizing descriptive accuracy of perceived externalities. Of building a good model of the external world. Two references: first, a basic blog on complexity:

• The First Law of Complexodynamics
  Scott Aaronson -- Shtetl-optimized blog -- Sept 2011
  https://scottaaronson.blog/?p=762

I don't like this blog post, but it does sort-of get a general idea across.

The other half is this:

• https://en.wikipedia.org/wiki/Internal_model_(motor_control)
• https://en.wikipedia.org/wiki/Good_regulator
• https://en.wikipedia.org/wiki/Mental_model

I'm interested in using entropy-complexity-type measures/systems to build "world models": models that accurately capture what the external world is like.

[linas]

Hmm. I guess its time for me to burn a few brain cells and find a concrete project/task?

The point of the "good regulator" is that a good AI system needs to build an accurate representation of the external world. That requires 3-4 parts:

• The ability to sense the external world
• The ability to process the sensation-results into memories
• A format for those memories that allows reasoning (inference, etc.)
• The ability to act so as to alter how the world is sensed.

There are fragments of the above all through the various atomspace subsystems; they've even been sort-of-hooked up, but the current design is a nasty patchwork. The meta-goal is to "make it better", and as one tries to "make it better", very specific, concrete coding tasks fall out. viz "to attach A to B I need to do C".

I have very specific A,B,C in mind, but that doesn't really align with where you want to go. So maybe I should make you create a proposal: "I want to do X which will require joining A to B" and then we can hash out details of how this could be done.

[sikefield3]

I think this theorem is general and broad enough to say "anything and everything that acts as a regulator must include a model of the thing it is regulating", and an engineer is not going to be able to magically evade that theorem. (The engineer might not know it applies)

But how does this model have to look like ? There is a mapping h mentioned that maps reality to the internal state of the regulator, but how "good" has this mapping to be ? Is there a threshold for the quality ? For example, if one is dealing with chaos, it might never be enough.

The allegory is then taken to the national scale: Any normal intelligent economic advisor to the President would strongly recommend that, if you want to balance the Budget (the household budget), you should simply stop paying the heating bills, since it is clear that nothing depends on them ("Here's a graph.") There's no economic correlation between these measured variables. Its just a waste of money. This may sound funny, to the point of being ludicrous, but apparently, this mistake keeps getting made over and over with regard to police budgets, medicare budgets, at the national, state, local level, and corporations make similar mistakes as well. ("the crime rate is low; why the heck are we putting more money into police departments?", or "Sales are booming! Why are we wasting money on customer support?" or more topically: "Why are we putting money into NATO? It just all goes to the pigs in the military-industrial complex. Just say no to war and yes to the multi-polar world!")

Of course, if one want to look at these kind of systems through this lens, there would need to be one big regulator that controls all the variables. For example, some social problems could be eased by other means than just police and incarceration (such as better education, affordable housing etc), so all of this is quite entangled.
At large, it seems somewhat reductionist too make such a map h for the complexities of the world.

Some tangent:
Even if the regulator / AGI finds new laws of physics, they have to be somehow compatible to the one we know already (see quantum correspondence) One would expect that suddenly some law or theory comes that reveals some deterministic nature in chaotic weather systems. That's mathematically impossible , right ?
Or expressed differently: Consider some chaotic system like weather or better yet the Three-Body-Problem. Now, an AGI might find a new theory of gravitation (QG), but this new theory has to predict the results of Classical Mechanics / General Relativity (GR), i.e. CM/GR has to approximate the new theory and the chaotic results in there. But maybe in this new QG, the chaos disappears or i.o.w. the chaos wasn't there in the first place, if we look at smaller scales than we can do now, the experimental results are "smooth" (damn: i don't know how to fit quantum theory in there!)
I don't know, maybe there is a theorem that prohibits this situation....

[sikefield3]

Hmm. I guess its time for me to burn a few brain cells and find a concrete project/task?

The point of the "good regulator" is that a good AI system needs to build an accurate representation of the external world. That requires 3-4 parts:

I have very specific A,B,C in mind, but that doesn't really align with where you want to go. So maybe I should make you create a proposal: "I want to do X which will require joining A to B" and then we can hash out details of how this could be done.

You have already mentioned a lot of ideas. I feel I should do some reading or go down some rabbit holes to get more familiar with the matter, maybe while doing something concrete ?

[linas]

regulator ... model ... but how "good" has this mapping to be ? Is there a threshold for the quality?

The prototypical regulator is the thermostat. It works with one bit of information: too hot or too cold. That's all it needs to get the job done. The 19th-century steam-engine regulator falls into the same class: that rotating flywheel-thing that cuts down on the amount of steam going to the engine when it spins too fast, and increases the steam when is spins too slow.

There are a large variety of "simpler" examples from bacteria and slime molds (which don't even have nerves) to the simplest animals (which do have neurons, e.g. jellyfish.) It only gets more complicated and ornate from there.

You have already mentioned a lot of ideas. I feel I should do some reading or go down some rabbit holes to get more familiar with the matter, maybe while doing something concrete ?

Yes, of course. There are many, many concrete tasks to be undertaken. The trick is to find one that is not too hard, and that is actually useful, and (I guess) fun enough that you're motivated to work on it. I was trying to invite you to propose something.

One interesting and concrete project is to extend the Atomese API to image-processing functions in OpenCV. This was started in https://github.com/opencog/vision but never got out of the proof-of-concept stage. Pushing this forward a bit farther is definitely a roll-up-your-sleeves and just-do-it type of thing. Once there's a handful of basic image-processing primitives, I wanted to hook it up to AS-MOSES https://github.com/opencog/asmoses and have it manage a learning process. This would require refactoring as-moses into 3 or 4 discrete stand-alone components. The as-moses work would be a large task, though. Perhaps it would be sort-of usable without major refactoring, but I dunno. After that, it would be a walk down the park of https://github.com/opencog/learn, but this time, doing it for images instead of (or, in addition to) words.

There are others, that are more closely related to the work you'd already done for the RocksDB backend. Maybe this is appealing, because it lands you in familiar territory. (Maybe it's unappealing, because it reminds you of an older burn mark?) This includes implementing some of the unimplemented ProxyNodes https://opencog.org/w/ProxyNode. Another is implementing frames for the cogserver (network API). A third is improving frames performance -- I noticed that using them seems factors of two or five or ten slower than not using them, so, for now, I'm avoiding them. But improving performance would be technically challenging. It's not like there's sloppy design in there; the design is pretty strong, so improving on it would be, well, I can't say impossible -- nothing's impossible, but it would require some lateral thinking.

[sikefield3]

One interesting and concrete project is to extend the Atomese API to image-processing functions in OpenCV. This was started in https://github.com/opencog/vision but never got out of the proof-of-concept stage. Pushing this forward a bit farther is definitely a roll-up-your-sleeves and just-do-it type of thing. Once there's a handful of basic image-processing primitives, I wanted to hook it up to AS-MOSES https://github.com/opencog/asmoses and have it manage a learning process. This would require refactoring as-moses into 3 or 4 discrete stand-alone components. The as-moses work would be a large task, though. Perhaps it would be sort-of usable without major refactoring, but I dunno. After that, it would be a walk down the park of https://github.com/opencog/learn, but this time, doing it for images instead of (or, in addition to) words.

That sounds cool...
I'm going to have a closer look in particular at the OpenCV stuff...
For now, I'm just setting up an LXD/LXC container, to try out the examples.

There are others, that are more closely related to the work you'd already done for the RocksDB backend. Maybe this is appealing, because it lands you in familiar territory. (Maybe it's unappealing, because it reminds you of an older burn mark?)

Yeah, at least for the moment, I'm feeling to get a bit distance from Rocks, even if it's more familiar...

[sikefield3]

I think I'm going to check out the examples to have a better what's going on and meanwhile do some more reading about complexity and regulator / controllers. There is also ethical regulators which I might ponder about...

[linas]

I am concerned that I am being too abstract, and not concrete enough, and this might be blocking you from making progress. I have some rather abstract mathematical, algebraic ideas, and I am trying to figure out how to turn them into working, high-speed code. I could explain these to you, but I suspect that you'd hit a brick wall (because I hit brick walls, regularly, and it takes hard work to get past them, and often I do it wrong.)

So I'm trying to figure out what I can point you at, that would be fun, productive & useful. But this is also a hard problem. Most to-do items are either incredibly hard theoretical issues, or things that feel like pointless, meaningless make-work (and its hard for me to explain why it's not pointless, meaningless, beyond "trust me, bro"). Bridging between the two is tough.

More in next post ...

[linas]

A tossed salad is a collection of ingredients, randomly mixed. Here is a (long) idea salad.

• Traditional machine learning takes a training corpus, applies some learning algo, to predict some output.
• Five years years ago, there were three general types of algos: neural nets, random forests, and "other miscellaneous". All of them were roughly, approximately tied in the accuracy of results, keeping model-size fixed, keeping parameter-space size fixed.
• They varied wildly in the complexity of the algo, the complexity of the theory, the difficulty of doing the training, and most importantly, the scaling: amount of CPU/RAM vs. size-of-problem.
• Deep learning/neural nets have "won" for two reasons: the algos are very scalable, and the algos are very simple. Back-prop is very efficient, spreading around the cost of a multiply so that it can be reused, and very local: it fits on one little itty-bitty GPU. Compare this to random forests: no one has been able to (has bothered to?) invent hyper-efficient algos for it. (maybe its not possible?)
• Lets look at LSTM as a good example. Here's a diagram from wikipedia:
• Note how above is a network of five yellow blobs, 4 orange blobs. Super-extremely simple. And yet, this most basic cell structure is capable of generating some fairly mind-blowing results: people were fairly awed by what this thing could do. (see assorted blogs, papers or even the wikipedia article on it).
• The AtomSpace is a generic system for storing and manipulating graphs, such as the graph above. Wouldn't it be cool if I could build this graph, hit a button and say "run" and it would run?
• The counter-argument is "you moron, you can already do this (and much much more) with sci-pi and tensorflow, etc. so why bother with the AtomSpace?" and the standard reply is "yes, but tensorflow, python, etc. are languages for human programmers to do human things, whereas AtomSpace allows meta-programming: it allows other algos to manipulate graphs, because they are graphs." So, for example, one could write a program to explore different possible graphs that specify different kinds of neural net architectures. And this could be done "automatically", without auto-generating python.
• So, doing the above would be a fairly interesting task. I think you could do it. Its pretty big, and pretty complicated, and there's a lot of hard parts and open questions, but I think it would be a cool trick, and fits your experience level and maybe fits your interests.
• There's already a similar project, already started, doing the above, but for image processing. It hooks up the OpenCV library API to AtomSpace atoms. It never got past proof-of-concept. See https://github.com/opencog/vision
• One issue with the above ideas is that the actual training infrastructure lies outside of the AtomSpace (or outside of scipy, outside of tensorflow): its a bunch of training corpora, giigabytes worth, downloaded off the internet, dumped into some directory, managed with shell scripts and perl scripts and what-not scripts to shove data from here to there, though some training pipeline (for neural nets, or whatever machine learning system you're training).
• The stuff here, in this git repo, https://github.com/opencog/sensory is about bypassing the ad-hoc hand-crafted shell scripts for pipelineing data through a learning algo, and, instead take an agent approach: The learner is an agent, it will explore the training set on it's own, instead of being force-fed down its gullet. The agent now has "free will", and the training set is "the external environment", and the agent can now "explore the environment", revisit this and that, move on to new things, as needed/desired.
• The "good regulator"/"world model" idea is that the agent is trying to explore the training corpus, and build an "accurate representation of it".
• All machine-learning systems build models of their training data. So that's not new. What is new is that the agent now has control over how it wants to walk over that data.
• For the short-term future, if all of the above got built, it does not really change anything. All that it does is replace shell scripts (which ordinary programmers understand) with Atomese (which looks like Plan 9 from Outer Space to most programmers) so one could say "wtf Linas bad idea"
• Well, and that now takes me to the forefront of the research program, and it gets very hand-wavey and abstract, here. I want to build a system that can explore how to create agents. One way to do this is to randomly create agents, and see how well they do. Another way is to randomly mutate agents, and keep mutations that improve performance. More generally, to apply other machine learning algos to learn agents.

This very last bullet is where I'm stuck, and am having trouble with making forward progress. There are four major issues:

• Build the infrastructure for the above. Its a huge task.
• Find the correct Atomese description/format/syntax for all the parts: so, in the LSTM example, not only encode the yellow and orange blobs as Atomese, but also encode the parameters. It is easy to do this in a brute-force, "obvious" fashion. Its hard to do it at a meta level, so, for example: an agent finds a blob. What's the name on the blob? "LSTM" What parameters do you have? "I have a,b,c, a is a float and b is a float and c is an integer" What inputs to you have? "I can read text". What output do you have? "I can generate text". Cool! So lets give you some inputs and parameters and lets see what happens. "CPU goes Brrrr..." I've got ideas on how to solve this, but it is a current pain point.
• The meta-meta level. Somehow, there's some meta-recursive aspect to this, that I don't understand. What's the agent that makes the agents? I've got this vague glimmer that "it will al be OK, in the end", and that the current approach of looking for correlates and looking for structures will scale up. (Very specifically, looking for pair-wise interactions, and then looking for maximum planar graphs that maximize overall Gibbs/Helmholtz free energy. I think this scales.) I think. but, being a hard-headed skeptic and doubter, it makes sense to doubt it. And so there are only two solutions: (1) build it, and see what actually breaks, doesn't work, or (2) theorize some more. The problem with (2) is that theorizing is hard. So I'm trying to do both at the same time, and am overwhelmed with the scope of the project.

Well, so that's the general status.