Category Archives: SynthNet

Article Featured on Qualcomm Spark Website

I realized while responding to some comments that I completely forgot to mention some exciting news!  Last month, I was fortunate enough to have an article featured on the Qualcomm Spark website, “Can We Grow Artificial Intelligence?”   It explores some of the capabilities we currently have of emulating DNA and biological growth, and incorporating these abilities into our normal programming tools to develop all sorts of AI.  I had a lot of fun writing it, as well as reading the other articles featured on the site.  So many exciting technologies on the horizon (or already here!)


Evolution Experimentation Module Complete

With the Genetic Mutation Engine completed, I wanted to put it to actual use.  While it’s fun to put complex SynthNet networks through the mutation process and watch the really cool looking results, manually doing it doesn’t really serve much of a purpose.  However, now that the Evolution Experimentation Module is complete, the real power of the mutation engine is unlocked.

Artificial Selection in Action

The Evolution module allows us to take an initial, manually created SynthNet network (as simple or complex as desired), test how effective it is in a task, and then either allow it to reproduce and continue on its genetic line, or prevent reproduction in the case of decreased task effectiveness.  It performs this across multiple “breeds”, or equally effective genomes, until a novel mutation shows improved performance, which is considered a new “species”.  This, in effect, emulates multiple genetic lines competing at a user-defined task, and artificial selection based on that task dictating the path of evolution of the SynthNet network.

Specifics of the module are as follows:

  1. Automatically and repeatedly mutates SynthNet DNA, grows its corresponding network, tests it, and records/compares the results
  2. Stores and manages all “breeds”, or equally effective genomes, across all mutations.
  3. Selects for new “species”, or more effective genomes, and blocks reproductions of less effective species.
  4. Detects cancerous (continuous) or unstable (requiring too much processor/memory to be feasibly used) networks and does not select for them.
  5. Can be used with any user-defined (programmed) task with a result that can be quantitatively graded, allowing full flexibility to direct artificial selection.
  6. Along with effectiveness, also stores structure (segment) count, neuron count, synapse count, effectiveness, and a graphical snapshot of each mutation.
  7. Stores all data into a MySQL database, to allow for easy continuation of experimentation after interruption, as well as viewing results on the web (coming soon!).
  8. Programmed in Python for easy use/alteration/integration.
  9. All interaction between the Evolution module and SynthNet is done via the Peripheral Nervous System Protocol, allow for remote use (allowing SynthNet to be run on a remoteserver with increased resources and client to be run at home).
  10. Also provides menu to send manual commands to a SynthNet network via PNSP for easy manual manipulation, testing, and troubleshooting.

I’m currently trying it out by artificially selecting for a neural network that can detect parity (even/odd) in numbers.  We’ll see how it does – once I have some results, I’ll be creating the front-end user interface to browse through mutations/results/pictures on the web.  Hopefully more on that soon!



Genetic Mutation Engine Functional

More SynthNet goodness today!  First off, I finished up the changes to the code that ensure all parts of SynthNet were relatively in sync with each other.  With one of my next big tasks being focusing on rate and temporal coding, timing within the system needs to be correct to support exact oscillating frequencies of action potentials, as well as resonance.  There were some significant changes to the code, so I needed to retest most parts of the entire program again.  That took up pretty much the month of August and beginning of Sept – all works well though!

Mutative Madness!

Before I took the next step and jumped into the neural coding work, I wanted to program the functionality that allows for the mutation of SynthNet’s virtual DNA, accommodating evolution experiments.  I finished up the mutation engine itself a couple nights ago, and am starting on the interface portion that will allow external programs to perform artificial selection experiments by monitoring the effectiveness of a DNA segment –  either continuing its mutation if successful, or discarding the genetic line and returning to a previous if less successful.

Below can be seen examples of the effects of mutation performed on a virtual DNA segment.  The first picture shows a network grown with the original, manually created DNA (the segment used in my classical conditioning experiment)

The next set of pictures show the results of a neural network grown using DNA that has undergone a .5% – 2% amount of mutation. Most were beautiful to look at, but the final two pictures were also completely functional, supporting the proper propagation of action potentials and integration of synaptic transmission – only with an entirely novel configuration!

Really amazing to look at (I think!)  Currently, SynthNet DNA can be exposed to the following types of errors in its genomic sequences:

  1. Deletion – Segments are removed entirely
  2. Duplication – Segments are copied in a contiguous block
  3. Inversion – Segments are written in reverse
  4. Insertion – Segments are moved and inserted into a remote section
  5. Translocation – Akin to Insertion, but two segments are swapped with each other
  6. Point Mutations – Specific virtual nucleotides are changed from one type into another

Currently, these operations result in in-frame mutations.  It was actually easier to allow frameshifts to occur – however, SynthNet DNA is more sensitive to framing, since whereas a biological read frame is across a codon (3 nucleotides), SynthNet DNA is variable from 1-6 virtual nucleotides.  When I allowed frameshifting, the results were high in nonsense mutations, which prevented almost any meaningful growth of neural structures.

Very excited with how things are turning out.  If, as seen in the last two pictures, we can get such novel pathway growth with a simple random mutation, I can’t wait to start the artificial selection routines and watch the results unfold!


Finished up Multithreading in SynthNet

With BerryCraft done for now, I’m jumping back into SynthNet again – finished up multithreading today.  Now the emulator can utilize multicores/multiple processors, which allows substantially larger neural networks (which means more complex behavior and fun to be had).  There is still quite a lot of optimization to be done, but this was the biggie by far – I wasn’t really able to make anything much larger than the previous test until I got this working.

I changed the DNA from the demonstration a bit and grew a network with more neurons in the neural pathway, then had it listen to a piece of music (The Duel from Electric Dreams).  Captured a quick video of it – no practical demonstration, but fun to watch!

Quick Shoutout –

James Pearn at was nice enough to include SynthNet in his list of resources related to artificial intelligence.  Check out his site if you get a moment, it serves as a well laid-out directory of many neural network and other artificial intelligence projects going on around the world, as well as job listings.  Very cool site – thanks James!


Watch SynthNet in Action!

In case you haven’t seen yet, the videos demonstrating SynthNet in action have been posted to YouTube!  In the first clip, I demonstrate growing a brain from virtual DNA, hooking into my Lego robotic buddy Bit, and then conditioning Bit to associate hearing a tone with getting his touch sensor pressed.  The demonstration is a recreation of classic fear conditioning experiments.

In the second clip, I give an explanation of how SynthNet functions, how the demonstration above was setup, and the future of the project.

Thanks for checking them out!


fMRI of Bit “Hearing” My Voice

This is what an fMRI of Bit’s (current) brain looks like while listening to my voice (red is active neural structures – it indicates a higher membrane potential). This will probably be the last picture before the video of the associative learning demonstration – I think I’ll be ready to record by Sunday night (hopefully). Exciting stuff!

Auditory Processing – Virtual Cochlea

Before Bit can hear like humans do, I needed to make a “virtual cochlea” – a piece of software that would take auditory input from a microphone, convert it into frequencies (like the hairs in your cochlea do), and send the data into Bit’s peripheral nervous system. I got most of it done tonight – I made a real-time graphing system as well. On the left, you can see the waveform data coming off the microphone (top is a straight tone coming off my KORG, and bottom is me talking), and to the right is the data run through a Fast Fourier Transform to convert the time-based waveform data into a frequency based distribution. This can then be sent directly into a neural nucleus in Bit’s brain via the TCP nervous system.

Increasing Network Complexity – Oscillating Neurons

As you can see from the membrane potential graph (lower left hand corner), I injected some current into this genetically grown virtual neuron (over a TCP connection), and it started keeping a steady pulse on its own – still going after 15 minutes!

Start of Multithreading Capabilities

Since the genetic engine is pretty much finished up now, I’ve started on some loose ends of things I want to implement in SynthNet. This is a stress test for the (start of the) new multithreading capabilities – using a simple strand of DNA to direct a base stem cell to continually go through mitosis and differentiate. These daughter cells then follow a genetically programmed spiraling migration path. You can see patterns start to emerge amongst the thousands of cells.

Some parts of the processing engine are crashing out right now, so it’s apparent I’m having some kind of issues arising from sharing information between threads – I’m going to shelve the functionality for now and then complete it up after the end of phase 1 – there may be quite a bit involved.