unh_cmac.c

一个老外写的CMAC Neural Network源代码和说明

	int i;
	
	if (field_shape == ALBUS) {
		for (i=0; i<num_state; ++i) 
			dv[i] = 1;
	} else {
		for (i=0; i<num_state; ++i) 
			dv[i] = 1 + (2 * i);
	}
}

/***************************************************************************
 *      init_rfield_table()                                                *
 *                                                                         *
 *      Input:          RF_TABLE_SIZE, field_shape                         *
 *      Output:         rf[]                                               *
 *                                                                         *
 *      Purpose:        Initialize receptive field function                *
 *                                                                         *
 ***************************************************************************/

static void init_rfield_table(int rf[], int table_size, int field_shape)
{
	int i;
	long il;

	/* set default constant field magnitude */	
	for (i=0; i<table_size; ++i) rf[i] = 1;
			
	/* now handle special non-constant cases */
	if (field_shape == LINEAR) {
		for (i=0; i<table_size; ++i) 
			rf[i] = (i + 1);
	}

	/* now handle special non-constant cases */
	if (field_shape == SPLINE) {
		for (i=0; i<table_size; ++i) { 
			il = (long)(i + 1);
			rf[i] = (int)((((long)-2 * il * il * il) + ((long)3  * il * il * (long)table_size)) 
					/ (long)table_size / (long)table_size); 
		}
	}
}

/* ********************************************************************* */
/**************************************************************************

The following CMAC functions CAN be called externally!

/***************************************************************************
 *      allocate_cmac()                                                    *
 *                                                                         *
 *      Input:          num_state,quant[],num_resp,num_cell,memory         *
 *      Output:         returns CMAC ID (1 - 7) if ok, 0 for memory error  *
 *                                                                         *
 *      Purpose:        Allocate memory and initialize CMAC parameters     *
 *                                                                         *
 ***************************************************************************/

int allocate_cmac(int num_state,int *qnt_state,int num_resp,
				int num_cell,int memory,int field_shape, int collide_flag)
{
	int i,j;
	int *pntr;

	/* initialize data structures on first call to driver */

	if (first_call) {
		genmap();
		for (i = 0; i <= NUM_CMACS; i++) ap_a[i] = 0;
		first_call = FALSE;
	}

	/* find an empty id */

	for (i = 1; i <= NUM_CMACS; i++) if (ap_a[i] == 0) break;
	if (i > NUM_CMACS) return(FALSE);  /* return 0 for no more cmacs */

	/* allocate CMAC storage */

	ap_size[i] = ((memory * (num_resp + 1)) + num_state + num_state + RF_TABLE_SIZE + 6) * sizeof(int);
	if (ap_a[i] = (int *)malloc(ap_size[i])) {
		pntr = ap_a[i];
		*pntr++ = num_state;        /* size of input state vector      	*/
		*pntr++ = num_resp;         /* dimension of response vector    	*/
		*pntr++ = num_cell;         /* generalization parameter        	*/
		*pntr++ = memory;           /* # of response vectors in memory 	*/ 
		*pntr++ = field_shape;		/* receptive field code				*/
		*pntr++ = collide_flag;		/* hashing collisions flag			*/
		for (j = 0; j < num_state; ++j)
		    *pntr++ = qnt_state[j]; /* input vector quantization 		*/
		init_disp_vector(pntr, num_state, field_shape); /* displacement vector */
		pntr += num_state;
		init_rfield_table(pntr, RF_TABLE_SIZE, field_shape); /* RF function */
		return(i);                  /* return cmac id number */
	} else {
		return(FALSE);
	}
}

/***************************************************************************
 *      train_cmac()                                                       *
 *                                                                         *
 *      Input:          cmac_id, state[], respns[], beta                   *
 *      Output:         ap[]                                               *
 *                                                                         *
 *      Purpose:        Train ap[] cells based on latest experience        *
 *                      state[] is mapped to indexes[] by stoap()          *
 *                                                                         *
 ***************************************************************************/

int train_cmac(int cmac_id,int *state,int *respns,int beta1,int beta2)
{
	int i, j, *weights;
	static long sum[MAX_RESPONSE_SIZE], error[MAX_RESPONSE_SIZE];
	static long delta1[MAX_RESPONSE_SIZE], delta2;

	if ((cmac_id < 1)|(cmac_id > NUM_CMACS)|(ap_a[cmac_id] == 0))
		return(FALSE);  /* reject bad ID */ 
		
	in_learn = TRUE;

	setup(cmac_id);  	/* init CMAC parameters */

	stoap(state);  	/* generate indices into ap[][] */

	for (j = 0; j < rsp_size; j++) {
		sum[j] = 0;
		delta1[j] = 0;
	}
	delta2 = 0;
	
	/* Process CMACs with rectangular RF field functions */
	
	if ((rf_shape == ALBUS) || (rf_shape == RECTANGULAR)) {
	
    	/* get old response */
	
		for (i = 0; i < gen_size; i++) {
			
			/* point to the weight vector for this RF */
						
			weights = &ap[indexes[i] * (rsp_size + 1)];
					
	        /* compute the experience sum */
		
	    	for (j = 0; j < rsp_size; j++)
				sum[j] += (long)weights[j];
		}
	
	    for (j = 0; j < rsp_size; j++)
			sum[j] /= gen_size;
				
    	/* compute adjustment due to reponse error */

		if (beta1 < 32) {
	    	for (j = 0; j < rsp_size; j++) {
				delta1[j] = ((long)respns[j] - sum[j]);
				if (delta1[j] >= 0)
					delta1[j] >>= beta1;
				else
					delta1[j] = -((-delta1[j])>>beta1);
		    	if (delta1[j] == 0) {
					if ((long)respns[j] > sum[j]) {
		        		delta1[j] = 1;
					} else if ((long)respns[j] < sum[j]) {
		        		delta1[j] = -1;
		        	}
				}
			}
		}

		/* adjust all weights of all RFs for response */
	
		for (i = 0; i < gen_size; i++) {
				
			/* point to the weight vector for this RF */
						
			weights = &ap[indexes[i] * (rsp_size + 1)];
					
	    	for (j = 0; j < rsp_size; j++) {
	    	
    			/* compute weight normalization adjustment */
	
				if (beta2 < 32) {
					delta2 = (long)(respns[j] - weights[j]);
					if (delta2 >= 0)
						delta2 = (delta2 >> beta2);
					else
						delta2 = -((-delta2) >> beta2);
				} 
				
				/* adjust the weight */
					
				weights[j] += (int)delta1[j] + (int)delta2;
			}
		}
		
		in_learn = FALSE;
		return(TRUE);
	
	} 
	
	/* Process CMACs with non-rectangular RF field functions */
	
	/* get old response */
	
	for (i = 0; i < gen_size; i++) {
			
		/* point to the weight vector for this RF */
						
		weights = &ap[indexes[i] * (rsp_size + 1)];
					
        /* compute the experience sum */
		
    	for (j = 0; j < rsp_size; j++)
			sum[j] += (long)weights[j] * rfield[i];
	}
	
	/* update old response in direction of observed response */

    for (j = 0; j < rsp_size; j++)
		error[j] = ((long)respns[j] * sum_rfield) - sum[j];

	/* adjust all weights of all RFs for response */
	
	for (i = 0; i < gen_size; i++) {
				
		/* point to the weight vector for this RF */
						
		weights = &ap[indexes[i] * (rsp_size + 1)];
					
    	for (j = 0; j < rsp_size; j++)  {
	    	
			/* compute adjustment due to reponse error */
		
			if (beta1 < 32) {
				if (error[j] >= 0) 
					delta1[j] = (((error[j] * rfield[i]) >> beta1) / sum2_rfield);
				else 
					delta1[j] = -((((-error[j]) * rfield[i]) >> beta1) / sum2_rfield);
		    	if (delta1[j] == 0) {
					if (error[j] > 0)
		        		delta1[j] = 1;
					else if (error[j] < 0)
		        		delta1[j] = -1;
				}
			}

			/* compute weight normalization adjustment */
	
			if (beta2 < 32) {
				delta2 = (long)(respns[j] - weights[j]) * sum_rfield * rfield[i];
				if (delta2 >= 0)
					delta2 = (delta2 >> beta2) / sum2_rfield;
				else
					delta2 = -(((-delta2) >> beta2) / sum2_rfield);
			} 
				
			/* adjust the weight */
					
			weights[j] += (int)delta1[j] + (int)delta2;
		}
	}
		
	in_learn = FALSE;
	return(TRUE);
	
}

/***************************************************************************
 *      adjust_cmac()                                                      *
 *                                                                         *
 *      Input:          cmac_id, state[], drespns[], beta                  *
 *      Output:         ap[]                                               *
 *                                                                         *
 *      Purpose:        Train ap[] cells based on latest experience        *
 *                      state[] is mapped to indexes[] by stoap()          *
 *                                                                         *
 ***************************************************************************/

int adjust_cmac(int cmac_id,int *state,int *drespns,int beta1)
{
	int i, j, *weights;
	static long error[MAX_RESPONSE_SIZE];
	static long delta1[MAX_RESPONSE_SIZE];

	if ((cmac_id < 1)|(cmac_id > NUM_CMACS)|(ap_a[cmac_id] == 0))
		return(FALSE);  /* reject bad ID */ 
		
	in_learn = TRUE;

	setup(cmac_id);  	/* init CMAC parameters */

	stoap(state);  	/* generate indices into ap[][] */

	/* Process CMACs with rectangular RF field functions */
	
	if ((rf_shape == ALBUS) || (rf_shape == RECTANGULAR)) {
	
    	/* compute adjustment due to reponse error */

    	for (j = 0; j < rsp_size; j++) {
			delta1[j] = (long)drespns[j];
			if (delta1[j] >= 0)
				delta1[j] >>= beta1;
			else
				delta1[j] = -((-delta1[j])>>beta1);
	    	if (delta1[j] == 0) {
				if (drespns[j] > 0) {
	        		delta1[j] = 1;
				} else if (drespns[j] < 0) {
	        		delta1[j] = -1;
	        	}
			}
		}

		/* adjust all weights of all RFs for response */
	
		for (i = 0; i < gen_size; i++) {
				
			/* point to the weight vector for this RF */
						
			weights = &ap[indexes[i] * (rsp_size + 1)];
					
	    	for (j = 0; j < rsp_size; j++) {
	    	
				/* adjust the weight */
					
				weights[j] += (int)delta1[j];
			}
		}
		
		in_learn = FALSE;
		return(TRUE);
	
	} 
	
	/* Process CMACs with non-rectangular RF field functions */
	
	/* update old response in direction of observed response */

    for (j = 0; j < rsp_size; j++)
		error[j] = (long)drespns[j] * sum_rfield;

	/* adjust all weights of all RFs for response */
	
	for (i = 0; i < gen_size; i++) {
				
		/* point to the weight vector for this RF */
						
		weights = &ap[indexes[i] * (rsp_size + 1)];
					
    	for (j = 0; j < rsp_size; j++)  {
	    	
			/* compute adjustment due to reponse error */
		
			if (error[j] >= 0) 
				delta1[j] = (((error[j] * rfield[i]) >> beta1) / sum2_rfield);
			else 
				delta1[j] = -((((-error[j]) * rfield[i]) >> beta1) / sum2_rfield);
	    	if (delta1[j] == 0) {
				if (error[j] > 0)
	        		delta1[j] = 1;
				else if (error[j] < 0)
	        		delta1[j] = -1;
			}

			/* adjust the weight */
					
			weights[j] += (int)delta1[j];
		}
	}
		
	in_learn = FALSE;
	return(TRUE);
	
}

/***************************************************************************
 *      cmac_response()                                                    *
 *                                                                         *
 *      Input:          cmac_id, state[]                                   *
 *      Output:         respns[]                                           *
 *                                                                         *
 *      Purpose:        Get the response vector based on experience        *
 *                      state[] is mapped to indexes[] by stoap()          *
 *                                                                         *
 ***************************************************************************/

int cmac_response(int cmac_id,int *state,int *respns)