Self-Reflective Interactive Realities

A.I. SpaceGraph

another reason for going directly to JOGL is that i see an opportunity to make an AI scenegraph
a scenegraph is just a framework for managing what drawing commands are performed
so what i'm saying is that certain parts of dANN could form that framework
which is why i wondered if dANN had anything like a quadtree or octree
it seemed similar to that VectorSet or VectorMap we were discussing
for using GraphDrawing to find contents in a hypersphere
a scenegraph is usually a DAG
i think a more appropraite term is 'SpaceGraph'
not scene
described here http://automenta.com/spacegraph

How does space graph differ from scene graph?

scenegraph is just a term used in computer graphics
i'm making a connection between AI and 2d/3d computer rendering
the other side of it, is input sensing
the mouse cursor for example (and multitouch too) generate a sequence of events
and changes in state
the input logic too could benefit from AI

2D Prototype

just working on a 2D model right now
which would be suitable for graph drawing (and interaction)
it does zooming and panning and now i can do intersection with rectangular areas

what i'm saying is that we can do even better than ordinary ‘scenegraphs’ potentially
whether it optimizes it or replaces it entirely

Why focus on user-interfaces rather than AI “work”?

because the graph drawing stuff could form the basis for a new desktop UI
and as a result, apps like netbeans would be obsolete
because we could in essence program directly into it
i'm thinking deeply about it because it may hold a chance of accelerating development, in the long long term
if the system can reason about its drawing commands, its input sense, and what it is working with, it will be completely reflectively AI
then the entire system state can be persisted in graphs and shared over the network
no need for the file system, trac, etc anymore
Git might be a good versioning system to use for serialized graphs
(there is JGit pure java impl of Git which can be used to make a virtual filesystem interface)
for example, code and issues would be linked explicitly
so realizing all this, i'm trying to make a simple 2D interactive framework that dANN can hook into this way
for at minimum, graph layout, text input, and drawing connections between things
i mean a user-inputted drawn connection
like sketches or wires
i think i've found a minimum list of UI functionality necessary to achieve this
full graph reflexivity
even typing the letter 'a' would start to bring up associations
'...is the first letter of English alphabet'

Dont you think for that to happen the AI needs to reach a more mature level?

everything necessary exists right now. its not really AI, just designing it in a way that it can be utilized by AI components like graphs, neural networks, genetic algorithms, etc
then as soon as we can construct those AI components from within the system, we can accelerate experimentation
because all of the results will be right there

Why move to JOGL instead of Java3D?

for interactive graph panning, zooming, and clicking buttons
JOGL is more direct
Java3D's scenegraph is nearly made obsolete when compared with Ardor3D or JME3
some of its terminology are really unweildly, like 'viewplatform' etc
anyway Ardor3D and JME use JOGL as their underlying OpenGL interface
https://jogl.dev.java.net/

Integrating Logic and Machine Learning

"We may be utilizing machine learning 'too little, too late'.  (IE, we're using too little ML and using ML not early enough).  Thus we may be already going down a slightly wrong path...  we should correct this by taking ML seriously and try to find the best way to incorporate ML in our architecture..." --YKY

interfacing with dANN has been my goal while designing Genifer's Java layer.  when it's finished, it will allow us to combine dANN's components with Genifer concepts.

dANN provides several "machine learning" (and related) components:

• dynamic bayesian networks
• many types of neural networks
• dimensional embedding aka graph drawing
• graph metrics
• etc...

Genifer's logic can remain in LISP -- Java may not be allowed to interfere - but the concepts will be reference-able

LISP will be able to bind formulas to Java method calls.  for example, using graph drawing:

List<Atom> getNeighbors(similarityGraph, center, radius)

so now that we know this, the question becomes: how do we create integrative designs that utilize Genifer and dANN as (internal) components?

well we could create many types of integrative designs.  though we may have a chance to evolve them: we can declaratively instantiate new instances of the system inside itself.

http://picocontainer.org/introduction.html


"Constructor Injection is a Dependency Injection variant where a component gets all its dependencies via its constructor."


"The most important benefits of Constructor Injection are:

• It makes a strong dependency contract
• It makes testing easy, since dependencies can be passed in as Mock Objects
• It is very succinct in terms of lines of code
• Classes that rely on Constructor Injection are generally Good Citizens
• A dependency may be made immutable by making the dependency reference final"

Systems like Picocontainer, and Spring Framework, are used to declaratively specify "wirings" of component dependencies.  This amounts to a hierarchical property tree listing the interfaces, implementation classes, and constant parameters in order to fill a "container" aka "context".

more later on this...