Spawn a system of concurrent, distributed, fault tolerant, and highly available intelligent agents for coordinated and/or uncoordinated action in one or many environments with no central point of failure. This project is Open Source.
The Automata Project combines the state-of-the-art AI control techniques with the latest research in autonomous decentralized systems, providing AI designers a flexible framework for creating valuable emergent properties in real world systems. The goal is to exhibit maximal Creativity & Open-Endedness for evolving new forms of useful intelligence. Natural Evolution took billions of years, so no rush.
This project is in the Alpha stage and not ready for production systems. We need Contributors to get to 1.0. We are eager for your contributions and very happy you found yourself here! Please join the slack channel and/or reach out to [email protected] if interested or with any questions. Here are our contributing guidelines and get up to speed on the wiki.
Note: This will be updated often. The direction of the project will change as the work evolves. We welcome any of your thoughts about roadmapping.
See the current milestones here.
Testing is currently happening using the mock sequence in world/mock_world/mock_automata/mock_seq_1.ex
. This is currently our canonical example of how to design a behavior tree (one type of Automaton
), and eventually communicates with other heterogeneous agents that you define in world/<mock_world>/<mock_automata>/<mock_automaton>
.
Currently, you can run the mock sequence in an iex shell as follows:
iex -S mix
iex(1)> Automata.spawn()
and tests can be run with debugging capabilities as follows:
MIX_ENV=test iex -S mix test test/unit/automaton/automaton_test.exs:23
where you are running a specific context/it block containing line 23.
-
Elixir & OTP provide the primitives for robust concurrent, fault-tolerant, highly available, self-healing distributed systems. The main point of the Erlang model is an application that can be expected to run forever, as stated by the language designer. Talk about unstoppable agents! Read more about the many benefits of Elixir and OTP.
-
Heterogeneous agents equipped with reasoning and knowledge components provide AI architects a selection of graphical, reinforcement learning, and neuroevolution based orchestrated agent constellations for a variety of real world environments.
-
Why and How Elixir? Elixir for world class communication & control fault tolerance and distribution. To overcome high dimensional function approximation limitations, we primarily focus on unsupervised learning and architecture search. Evolutionary architecture search (EAS?) evolves populations of feed-forward neural networks without computationally expensive backpropagation. However, Mixture of Experts (MoE) Deep Learning is on the roadmap and will be accomplished by leveraging Python, Julia, or Rust inter-operability or microservices.
The maps of the territory. Without good maps, any explorer could easily get lost. To fit the information available to the problem at hand, we separate representations into distinct layers with well defined boundaries.
All agents have some formulation of action selection, otherwise they would never achieve their goals. To keep agent decision making correct, we fit the mode of reasoning to the representation.
Interchangeable memory modules across short term working memory, blackboards, and knowledge bases.
Read the wiki and/or the docs for more about the technologies underlying Automata
.
Autonomy is the capacity of agent(s) to achieve a set of coordinated goals by their own means (without human intervention) adapting to environment variations.
It combines five complementary aspects:
- Perception e.g. interpretation of stimuli, removing ambiguity/vagueness from complex input data and determining relevant information based on context/strata/motif specific communications
- Reflection e.g. building/updating a faithful environment run-time model
- Goal management e.g. choosing among possible goals the most appropriate ones for a given configuration of the environment model
- Planning to achieve chosen goals
- Self-adaptation e.g. the ability to adjust behavior through learning and reasoning and to change dynamically the goal management and planning processes.
Note that the five aspects are orthogonal. The first two aspects deal with “understanding” the map of the environment. The third and the forth aspects deal with autonomy of decision. Self adaptation ensures adequacy of decisions with respect to the environment map. See MMLC2.
A system is defined as an Autonomous Decentralized System (ADS) if the following two properties are satisfied:
-
Autonomous Controllability: Even if any subsystem fails, is repaired, and/or is newly added, the other subsystems can continue to manage themselves and function.
-
Autonomous Coordinability: Even if any subsystem fails, is repaired, and/or is newly added, the other subsystems can coordinate their individual objectives among themselves and can function in a coordinated fashion.
Planned builtin and/or custom third-party agent types include:
-
Graphical Model Based
- Behavior Trees
- Generalized Probabilistic Models
-
Reinforcement Learning (RL) Based
- Bandits
- td-learning, q-learning, actor-critic
- Deep Learning, Gann
- DEC-POMDP (Decentralized Partially Observable Markov Decision Process)
-
Neuroevolution
- TWEANN (Typology and Weight Evolving Artificial Neural Network)
The central problem of artificial intelligence is how to express the knowledge needed in order to create intelligent behavior. — John McCarthy, M.I.T/Stanford Professor, Creator of Lisp
- A global blackboard that can coordinate automata without being a central point of failure.
- Individual automaton blackboards readable by all automata, writeable by owning automaton
- Meta-level control to support agent interaction, any potential network reorganization. Meta-level control is the ability of an agent to optimize its long term performance by choosing and sequencing its deliberation and execution actions appropriately. 2
- potentially bringing the code to the data rather than the other way around.
- Learn more about the performance features of
Automata
- Trading Systems
- Pandemic Testing Drone Units
- Patient Monitoring & Care Systems
- Swarm Intelligence / Distributed Robotics
- Intelligent agents with soft realtime multi-dimensional sensory, perception, intuition, and action capabilities
- Multi-Agent Reinforcement Learning (MARL)
- Mixture of Experts (MoE) Deep Learning Control Systems (python inter-op with erlport)
- Blockchain Smart Contract Systems
- A Mega-constellation of satellites
- 3D Printing and Factory Automation
- Product Automation & Analytics
- Augmented, Virtual, Mixed Reality Backends
- Smart Home / IOT Systems
- High-Speed Rail Systems (Japan has an ADS railway that learns)
- Chatbot & Game AI's (esp. MMOG user/npc backends)
- QA Testing (BT's are particularly suited to combinatorial testing)
- ? (choose your adventure)
defmodule MyAutomaton do
use Automaton,
# required
type: :behavior_tree,
# the remainder are required with type :behavior_tree.
node_type: :selector,
# the heartbeat for this node(subtree), in milliseconds
# the default is 50ms (mimics the average human brain perception cycle time)
# heartbeat adaption as meta-level(automata) action, to be changed at runtime
tick_freq: 50, # 50ms
# excluded for execution nodes
# list of child control/action(execution) nodes
# these run in order for type :selector and :sequence nodes and in parallel
# for type :parallel, and in a user-defined dynamic order for :priority
children: [ChildAction1, ChildSequence1, ChildAction2]
@doc """
Required with `type: :behavior_tree`
- Called every tick, must return `{:ok, status}` or `{:error, reason}`
## Reactively and Proactively Change the World
> ie.. effect the current environment in phases using
either actuator *effectors* or via *communication* with
other agents and/or internal/external systems
"""
def update do
{:ok, status}
end
end
Below is a simplified hypothetical example of a :behavior tree
sequence control node(subtree) for an autonomous "Forex Trader". The first two leafs are condition nodes, and the last two are action nodes.
If available in Hex, the package can be installed
by adding Automata
to your list of dependencies in mix.exs
:
def deps do
[
{:automata, "~> 0.1.0"}
]
end
- Eric Steen - upstarter
See also the list of contributors who participated in this project.
This project is licensed under the Apache 2.0 License - see the License.md file for details or