This is Java lab for developing and experimenting with brand-new AI technology. The technology is fully my own and hadn't been published anywhere. Core code is non-commercial for now and will always be non-commercial in future while commercial product based on it are feasible.
The idea is based on principles of self-organization where the network structure adaptively grows by interfering between previous and current states shapshots. It has long-term memory written in network structure and short-term memory written in nodes and edges states.
The model does not use complex math formulas for a neuron or synapse behavior. All computations are performed on graph where each node acts like a gate to the input abstract flow which is divisible but equal.
While the core logic certainly will have few SLOC the abilities are expected to be very wide and powerful.
| Tag | Description |
|---|---|
| Neural network | Here are Receptor, Effector and Neuron abstractions. |
| Self-organization | Local rules only are applied while the network grows. |
| Reinforcement learning | No supervisor at all. True Black Box abstraction. |
| Structural adaptation | The network adjusts its structure adapting to the input signals. |
| Associative memory | The network use biologically inspired Reflexes for forming of Associations. |
| Mathless approach | There is no math at all used in algorithms on network grow. |
- Zoo of AI applications
I use awesome GraphStream library for layout of the network. Visualization is aimed mostly for development and showcase purposes.
Green color is for Excitatory synapses, Red color for Inhibitory ones.
Static and Dynamic layouts can be applied as follows
List<NetworkEventsListener> listeners = List.of(
new LayoutAdapter(new GraphStreamStaticLayout()),
new LayoutAdapter(new GraphStreamDynamicLayout()));
Network network = new Network(listeners, 400);It just an adjacency matrix of underlying directed graph. The Flow (core concept expression) passes from bottom to left side of matrix. The circles are neurons aka nodes. The squares stay for edges. Static layout has an event-based methods for to react to Flow bypassing through nodes and edges - this is why different squares opaqueness and circles sizes are happened.
Below is the basic example on how the network grows using GraphStream's out-of-the-box dynamic layout. Note, the recording shows a very simple graph layout while complex ones are totally unreadable and useless.
Proof-of-concept, Single-threaded, Non-optimized, Ugly sometimes
Next milestone: Reinforcement learning and associative formation are fine-tuned
- The original Self-organized Neural Network pet project rewritten from the scratch
- Abstract Nodes and Edges, Graph draft. Check the Core package
- Concrete Receptor, Effector, PainEffector, Neuron (aka hidden network unit) in Neural package
- Network self-organized growing
⚠️ Implemented an ugly workaround solution in core - should fix it
- Associative memory formation using bio-inspired Reflexes.
- Different kinds of Receptor. See Network code
- basic reception for any single Object
- reception for set of objects bounded to specific receptor (strict or dictionary)
- adaptive (auto-extensible, on-demand) reception
- floating point values bucketing
- PainEffector as core mechanism to Reinforcement Learning paradigm implementation
- Event-driven Network visualization, see Visualization package
- Static layout (adjacency matrix)
- Dynamic layout (graph) supporting events from every subclass of Node
- Real-world application samples
- Outlier detection on multivariate data. Code is here.
- Spatiotemporal Pattern recognition on multivariate time-series data with noise. Code is here
- Playground and Samples for
- Associative memory formation
- Reinforcement learning
- Single pass Network (continuous) training
- Supervised network constructing
- Wiki pages
- Add samples covering most of Real-world applications
- Clone the project. Open it in your favorite IDE.
- Start exploring Playground package or Samples package
- or create your own class with main method with contents as below
Random random = new Random();
Network network = new Network();
network.addListener(new LayoutAdapter(new GraphStreamStaticLayout()));
network.addListener(new LayoutAdapter(new GraphStreamDynamicLayout()));
network.addReceptor(random::nextBoolean);
network.addReceptor(random::nextBoolean);
network.addReceptor(random::nextBoolean);
network.addReceptor(random::nextBoolean);
for (int idx = 0; idx < 20; idx++) {
network.tick();
Thread.sleep(50);
}There is NO Intelligence in terms of condition we can measure. It's all about natural selection. Nature just eliminates all the species which do not conform to current conditions. We just observe symptoms calling it Intelligence.
Everything that can accept flow from outer environment then split it using itself inner structure and finally get it back to outer media is already intelligent. The nature of the flow is irrelevant. It can be neurotransmitters and hormones or enumerated emotions each bounded to certain Receptor implemented in Java code.
I doubt you can realize the underlying technology with no articles describing it. So just hold tight and wait 😀