Okay - I've put this one off long enough.  Now that the new vblob() code seems to be stable, we need to add the long-promised neural net functions.
 
The basic plan is to start first with console functions, and then follow up with support in C and Scheme.  The core code is here -  
    http://code.google.com/p/surveyor-srv1-firmware/source/browse/trunk/blackfin/srv /neural.c
 
This code is configured to match 8x8 pixel patterns, which means that we have a net with 64 inputs.  This isn't a hard limitation, and we can build larger nets, but we'll use this as a starting point.
 
If you look at the neural.c code, you'll see that we already have some pre-programmed 8x8 pixel patterns, represented like this
 
pattern_t pattern[] = {
    {  // solid ball
    {    0,    0,    0, 1024, 1024,    0,    0,    0,
        0, 1024, 1024, 1024, 1024, 1024, 1024,    0,
        0, 1024, 1024, 1024, 1024, 1024, 1024,    0,
     1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024,
     1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024,
        0, 1024, 1024, 1024, 1024, 1024, 1024,    0,
        0, 1024, 1024, 1024, 1024, 1024, 1024,    0,
        0,    0,    0, 1024, 1024,    0,    0,    0 },
    { 1024, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
    },  
 
That means of storage is very inefficient, so the first step in modifying the code will be to collapse the pattern storage to 8x8 bits (8 bytes).  As such, the above pattern would collapse to
    { 0x18, 0x7E, 0x7E, 0xFF, 0xFF, 0x7E, 0x7E, 0x18 }
 
Initially, we'll support 16 different 8x8 patterns, and will allow overwrite of the built-in patterns using 'np'  followed by the pattern number 0-F, followed by the 8 bytes in hex format.  So to program the above pattern into neuron "bin" #0, the command will be
    np0187E7EFFFF7E7E18
 
Also, we'll need a function to display stored patterns
    nd #
 
I'm not certain yet whether we will have the addition of a new pattern automatically trigger a retraining of the net, or whether we'll use a specific command for training, e.g.
    nt1000     (neural-net train 1000 * 1000 iterations)
 
Two other commands:
 
One to initialize the net
    ni
 
One will be for testing the network with a user specified pattern
    nx1E7C7EFDFF7E7B1C
 
One will use blob coordinates to scale a color segmented portion of the live image down to 8x8 dimensions and pattern match against the stored patterns
    nb   color#  blob#
 
So, in summary, here are the commands we will add initially -
 
np - store a new pattern
nd - display a stored pattern
ni  - initialize the network with random weights
nt  - train the network from stored patterns
nx  - test the network with sample pattern
nb  - match pattern against specific blob from "vb"
 
Comments ?
 
 

This shouldn't take more than a day to code.  If there aren't any distractions, I'll probably start on it tomorrow, as I finally have a pretty clear idea of what approach to take.

Exactly.
 
The net will have 64 inputs and 16 outputs, corresponding to how well each of the stored patterns matches the input pattern.   My plan is to dump out the score (0 - 100) for each of the pattern matches, though it would make sense to first display the index of the best match.  So for example, if the best matching pattern was #5, the data for patterns 0-15 might look like
    15  10  7  20  15  85 ... ... 15
 
So we might display the result from nx, nb, or nc in this format -
 
##nx 5    15 10 7 20 15 85 ... ...
 
Once we move these into C and Scheme calls, the return value would be the index of the best matching pattern, but it will be useful to see the raw data in the console version of the functions.
 

Now that the neural net code is included in the posted firmware, can you please post a short tutorial on just what the proper steps are to utilize it?

I have been thinking about the blob scaling for neural net processing, and have decided that for the present, we won't worry about matching patterns with non-square aspect ratios.  So the plan is the scale any arbitrary blob to an 8x8 pattern for input to the neural net.  So in the case of these blobs
 

 
##vb0
1344 - 114 156 78 198  
1221 - 50 96 73 195  
932 - 174 212 77 192  
641 - 230 264 82 186    
 
where dimensions were typically around 40 wide by 120 tall, we'll squish the 1:3 aspect ratio down to 1:1 in an 8x8 image.  So that means that 5 x 15 pixels will subsample down to each of the 8x8 pixels (i.e. the inputs to the neural net), by counting each of those 75 pixels to come up with an average value.  As a result, the pattern matcher will think it's looking at an image like this -
 

 
Hopefully, I will have a chance to code this tomorrow, replacing the current builtin patterns with numeric patterns '0' - '9' and maybe some math symbols ('+'  'x'  '/'  '=', using '~' for '-') to populate remaining slots.  I suspect we will be expanding the limit on number of patterns before long.

Glad to see that someone else is trying this...
 
Make certain to first initialize the neural net weights by sending "ni"
 
Each time you send nt, it will train for 10000 iterations.  The training results are dumped out on completion, with the patterns tested against the network, so you'll see a diagonal line of matches.  The value of each match should be 95+.  I've never seen values less than 101 after a single round of training, so I wonder why you are getting different results.
 
Sorry I haven't been able to post the neural blob function yet - events have conspired against me today. It's still at the top of my list.

Try running "ni" each time before you run "nt".
 
I'm getting pretty consistent results -  
 
ni
##ni - init neural net
np57830303030303078
##np 5
nt
##nt - train 10000 iterations
 102   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
   0 102   0   0   0   0   0   0   0   0   0   0   0   0   0   0
   0   0 102   0   0   0   0   0   0   0   0   0   0   0   0   0
   0   0   0 102   0   0   0   0   0   0   0   0   0   0   0   0
   0   0   0   0 102   0   0   0   0   0   0   0   0   0   0   0
   0   0   0   0   0 102   0   0   0   0   0   0   0   0   0   0
   0   0   0   0   0   0 102   0   0   0   0   0   0   0   0   0
   0   0   0   0   0   0   0 102   0   0   0   0   0   0   0   0
   0   0   0   0   0   0   0   0 102   0   0   0   0   0   0   0
   0   0   0   0   0   0   0   0   0 102   0   0   0   0   0   0
   0   0   0   0   0   0   0   0   0   0 102   0   0   0   0   0
   0   0   0   0   0   0   0   0   0   0   0 102   0   0   0   0
   0   0   0   0   0   0   0   0   0   0   0   0 102   0   0   0
   0   0   0   0   0   0   0   0   0   0   0   0   0 102   0   0
   0   0   0   0   0   0   0   0   0   0   0   0   0   0 102   0
   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0 101
nx3030303030303030
##nx
   0   0   0   0   0  97   0   0   2   0   1   0   0   0   0   0
np53c1818181818183c
##np 5
nt
##nt - train 10000 iterations
 102   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
   0 102   0   0   0   0   0   0   0   0   0   0   0   0   0   0
   0   0 102   0   0   0   0   0   0   0   0   0   0   0   0   0
   0   0   0 102   0   0   0   0   0   0   0   0   0   0   0   0
   0   0   0   0 102   0   0   0   0   0   0   0   0   0   0   0
   0   0   0   0   0 102   0   0   0   0   0   0   0   0   0   0
   0   0   0   0   0   0 102   0   0   0   0   0   0   0   0   0
   0   0   0   0   0   0   0 102   0   0   0   0   0   0   0   0
   0   0   0   0   0   0   0   0 102   0   0   0   0   0   0   0
   0   0   0   0   0   0   0   0   0 102   0   0   0   0   0   0
   0   0   0   0   0   0   0   0   0   0 102   0   0   0   0   0
   0   0   0   0   0   0   0   0   0   0   0 102   0   0   0   0
   0   0   0   0   0   0   0   0   0   0   0   0 102   0   0   0
   0   0   0   0   0   0   0   0   0   0   0   0   0 102   0   0
   0   0   0   0   0   0   0   0   0   0   0   0   0   0 102   0
   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0 101
nx1818181818181818
##nx
   0   0   6   0   0  78   0   0   0   0   0   0   0   0   0   0
nx3030303030303030
##nx
   0   0   0   0   0 101   0   0   0   0   1   0   0   0   0   0
nd5
##nd 5
      ** ** ** **      
         ** **          
         ** **          
         ** **          
         ** **          
         ** **          
         ** **          
      ** ** ** **      
nx3838383838383838
##nx
   0   0   0   0   0  99   0   0   2   0   0   0   0   0   0   0
nx3c3c3c3c3c3c3c3c
##nx
   0   0   0   0   0   0   0   0 102   0   0   0   0   0   0   0
 

Perhaps a better idea - instead of the pain of coding these patterns, we should have a command that can grab an actual blob as the template for the input pattern to be saved, e.g.
    "ng"  pattern#   (this will grab the largest blob as pattern input)
 
then use
    "nd" pattern#  
to see what we captured
 
So the entire training sequence, assuming colors had already been set with "vc", would look like
 
vb0    (do a blob search on color #0)
ng5    (grab and save pattern #5 from largest blob)
nd5    (display the results)
ni       (if satisfied with results, retrain the network)
nt
 
then to test the result
 
vb0    (do a blob search on color #0)
nb0    (look for best match in neural net against largest blob)