CMAC History         Explanation             Code              Chris's Research                 Publications

Chris is interested in further developing the type of artificial neural network known as CMAC and applying it to a wide variety of control problems. 

In 1972 James Albus invented the Cerebellar Model Articulation Controller, a computer algorithm designed to mimic the neural pathways he observed when dissecting a human cerebellum.  The cerebellum is the part of our brain that knows the right nerve signals to send to our muscles to accomplish the body movements we desire i.e. it is the control system of the brain.  Later, Albus envisioned even more applications of his algorithm and renamed it the Cerebellar Model Arithmetic Computer, but still maintaining the acronym CMAC.  He was slightly ahead of his time, as computer technology was not quite advanced enough to run the algorithm in a real-time controller.   In the 1980s Thomas Miller III, at the University of New Hampshire, brought the CMAC to the wider attention of the control systems and robotics communities by demonstrating successful experimental results, at first with an industrial robotic manipulator and later with a biped walking robot.  Since CMAC can both learn quickly and handle many inputs, it would appear to be superior to other types neural networks for control systems applications.  However, CMAC was not widely embraced due to its tendency for overlearning, a problem that Chris has endeavoured to fix...

The basic building block of an n-input CMAC is an N-dimensional array (or look-up table),  where each array is divided into q quantizations per input.  The CMAC uses m offset arrays (or layers) to achieve the approximation and generalizationn properties of a neural network (Fig. 1 above). Each hypercube cell in an array defines the domain of a basis function; the original CMAC used binary basis functions, but contemporary CMAC design typically utilizes basis functions that go to zero at the cell boundaries i.e. triangular or spline (Fig. 2 below).   The CMAC is an associative memory and works in a similar fashion to radial-basis-function (RBF) networks: each input defines a dimension of a basis function and a weighted sum of basis functions provides the output.   However, the CMAC avoids the ``curse of dimensionality'' found with RBF networks in on-line calculations by considering only the one-per-array m indexed, or activated, cells (rather than all mq^n)  to calculate the output.  In addition, the CMAC uses a random-hash coding scheme to avoid allocating memory for all the cells, the vast majority of which will never be accessed as input trajectories move through high-dimensional space.

global BETA NU
global NUM_LAYERS NUM_Q MEMSIZE NUM_INPUTS
global MAX_STATE MIN_STATE HASHTABLE memory

initialize_cmac();   %see function below

states=define_initial_state(); %function not provided here

for i=1:length_of_simulation

     time=time+time_step;

     desired_states=trajectory(time); %function not provided here

     inputs=[states; desired_states];

     training_error=calculate_error(states, desired_states); %function not provided here

     [basis_functions locations]=cmac(inputs); %see function below

     cmac_output=0;

     for j=1:NUM_LAYERS %calculate the output
         cmac_output=cmac_output+basis_function(j)*memory(locations(j));
     end;

     states=simulation_or_hardware_one_time_step(states, cmac_output); %function not provided

     for j=1:NUM_LAYERS %update the activated weights
         weight=memory(locations(j));
         memory(locations(j))=weight+BETA*(basis_function(j)*training_error-NU*weight);
    end;

end; %for i=1:length_of_simulation

function initialize_cmac()

    global BETA NU
    global NUM_LAYERS NUM_Q MEMSIZE NUM_INPUTS
    global MAX_STATE MIN_STATE HASHTABLE memory

    BETA=1;  %adaptation/learning gain
    NU=0.01;  %if NU is too small, overlearning (weight drift and bursting)will occur

    NUM_LAYERS = 100;     %Number of arrays or layers - somewhere between 50 and 500 usually
    NUM_Q = 10;                 %Number of quantizations per input, keep 10 if using the 'rule' below
    MEMSIZE = 50000;         %Size of physical memory - make as big as possible

    %rule of thumb: make the size of CMAC dimension about 10 times the size of the actual...
    %...input range you forsee, if you are using NUM_Q=10

    MAX_STATE=[0.3 0.45 0.2 4.2];  %fill in your own appropriate values
    MIN_STATE=[-0.3 -0.45 -0.67 1.2]; %fill in your own appropriate values
   NUM_INPUTS = length(MAX_STATE);  % or try using less and see if performance improves

    % initialize static CMAC hashtable array
    for i = 1:NUM_INPUTS*NUM_LAYERS*NUM_Q
        HASHTABLE(i) = 1000000.0*rand();
    end

     % choose CMAC array offsets - random is fine
         for i = 1:NUM_INPUTS
             for j = 1:NUM_LAYERS
                 if j == 1
                     OFFSET(i,j) = 0.5;
                else
                    OFFSET(i,j) = rand();
                end
            end
         end

    memory=zeros(MEMSIZE,1);

end; %end of initialize_cmac

function [basis_functions locations]=cmac(original_inputs)

     global NUM_LAYERS NUM_Q MEMSIZE NUM_INPUTS
     global MAX_STATE MIN_STATE HASHTABLE

     % normalize instantaneous input within input range
     input = (original_inputs(1:NUM_INPUTS) - MIN_STATE(1:NUM_INPUTS));
     input = input./(MAX_STATE(1:NUM_INPUTS) - MIN_STATE(1:NUM_INPUTS));
     input = min(input, ones(NUM_INPUTS,1));     
     input = max(input ,zeros(NUM_INPUTS,1));

    for j = 1:NUM_LAYERS %number of arrays or layers
    
        basis_functions(j) = 1;
        add_locations = 0;
    
        for i = 1:NUM_INPUTS %number of inputs or dimensions
            place = input(i)*(NUM_Q - 1) + OFFSET(i, j); %locate position within activated cell
            cell(i) = floor(place);      %locate activated cell number
            h = place - cell(i);  %yield position within activated cell on this dimension (between 0 and 1)
            func = 16*(h*h - 2.0*h*h*h + h*h*h*h); %calculate spline output
            basis_functions(j) = basis_functions(j)*func; %creating multi-dimensional basis function
            index=cell(i) + 1 + NUM_Q*(j-1) +NUM_Q*NUM_LAYERS*(i-1);
            add_locations = add_locations + HASHTABLE(index); %create summation for hash coding
        end; %for i = 1:NUM_INPUTS
    
        locations(j) = int32( floor( mod(add_locations,MEMSIZE-1)) ) + 1; %hash coding

    end %for each layer
    basis_functions= basis_functions./sum(basis_functions); %normalize basis functions

end; %cmac

Chris has proposed several methods for preventing overlearning in CMAC (see publications below) which should allow CMAC to reach its full potential in a wide variety of control applications.  Researchers and engineers can use these methods to design adaptive controls for many types of nonlinear systems where the nonlinearities and parameters are unknown, and disturbances are significant.  Current research efforts are geared towards quantifying stability bounds for these methods and testing them in a wide variety of applications.

Here are some links to publications where CMAC was utilized and/or improved.