Introducing Membrane: Distributed AI system using Cellular structures
This is a skunkwork project for Distributed Cellular AI systems.
The objective is to expose skeletal cellular interfaces that allow building intelligent information systems based on Cellular structures.
The applied motivation comes from Tensorflow and neural nets. The abstracted layer could encapsulate the underlying implementation for training models. The desired salient features for such a framework would be:
- Models could be trained using underlying ML implementations making it easier to treat non-ML details to scale operations onto distributed cluster nodes.
- Since prediction accuracy depends on training data, the time taken to train models is not optimal.
- Training data could be sliced and ingested parallely, taking principles from MapReduce and each cell could be trained faster. Ofcourse, this would mean an inter-communication between cell mesh would be the asynchronous way to communicate the model development accurately. This is the desired ambition.
Alot of the non-applied motivation is documented here:
https://codecakes.github.io/membrane
Membrane was inspired by the podcast “Under The Skin” with Russel Brand featuring Bruce Lipton(details of which are provided in the aforementioned link ☝️)
Fundamentally it starts with defining a cell:
%Cell{ cell_id: pos_integer | bitstring, receptor: term, signal: term, nucleus: term }
A Cell’s lifecycle then becomes honing ML models, better training and shaving off unhealthy cells. Once the cells are ready to split, reproducing becomes easy:
@typedoc """ Reproduces a cell into two daughter cells replicating from the original copy. """
@type reproduce_t :: (%{ :cell_id => cell_id :: Cell.cell_id_t, :cell_stages => cell_stages :: cell_stages_t, } -> {new_cell_state_ :: new_cell_state_t, new_cell_state :: new_cell_state_t})
@spec replicate(lifecycle_eligibility_checks, reproduce_t) :: list(new_cell_state_t) def replicate(%{}, reproduce_fn)
# lifecycle_eligibility_checks
# reproduce end
