ProfitPress Mega CDROM2 Shareware Freeware (MSDOS)(1992)(Eng)

home *** CD-ROM | disk | FTP | other *** search

/ ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng) / ProfitPress-MegaCDROM2.B6I / PROG / MISC / NASANETS.ZIP / BUILDNET.C < prev next >

Wrap

C/C++ Source or Header | 1990-06-07 | 37.5 KB | 871 lines

/*=============================*/ /* NETS */ /* */ /* a product of the AI Section */ /* NASA, Johnson Space Center */ /* */ /* principal author: */ /* Paul Baffes */ /* */ /* contributing authors: */ /* Bryan Dulock */ /* Chris Ortiz */ /*=============================*/ /* ---------------------------------------------------------------------- Code For Construction Of Net Structures (Prefix = B_) ---------------------------------------------------------------------- This code is divided into 4 major sections: (1) include files (2) externed functions (3) externed global variables (4) subroutines Each section is further explained below. ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- INCLUDE FILES ---------------------------------------------------------------------- */ #include "common.h" #include "weights.h" #include "layer.h" #include "net.h" #include "netio.h" /* ---------------------------------------------------------------------- EXTERNED FUNCTIONS ---------------------------------------------------------------------- Below are the functions defined in other files which are used by the code here. They are organized by section. ---------------------------------------------------------------------- */ extern float LR_learn_default(); extern float LR_momentum_default(); extern float LR_scale_default(); extern float LR_learn_from_scale(); extern Layer *L_alloc_layer(); extern Layer_lst *L_alloc_layer_lst(); extern Layer_lst *L_insert_before(); extern void L_free_layer(); extern void L_free_layer_lst(); extern Weights *W_alloc_weights(); extern Weights_lst *W_alloc_weights_lst(); extern Weights_lst *W_insert_before(); extern void W_weight_range(); extern void IO_my_get_string(); extern float IO_get_default_float(); extern void IO_print(); extern void IO_insert_format(); extern Layer_spec *PS_get_layer(); extern void PS_reset_for_layer_parse(); extern int PS_global_spec_check(); extern Sint C_float_to_Sint(); extern char *sys_alloc(); extern void sys_free(); /* ---------------------------------------------------------------------- EXTERNED GLOBALS ---------------------------------------------------------------------- Note that one global here is externed ONLY if we are in delivery mode. If so, this global is used to indicate whether or not the delivery network uses bias values. That is, the delivery code will define the "bias_flag" global properly to indicate the presence of biases. ---------------------------------------------------------------------- */ extern float global_learn_base; extern float global_momentum; extern char IO_str[MAX_LINE_SIZE]; extern char IO_wkstr[MAX_LINE_SIZE]; /* ====================================================================== ROUTINES IN BUILDNET.C ====================================================================== The routines in this file are grouped below by function. Each routine is prefixed by the string "B_" indicating that it is defined in the "buildnet.c" file. The types returned by the routines are also shown here so that cross checking is more easily done between these functions and the other files which intern them. Type Returned Routine ------------- ------- Net * B_create_net int B_process_config int B_create_wts int B_check_layer_sizes void B_setup_net void B_setup_learning void B_set_layer_learning void B_set_layer_momentum Net * B_free_net ====================================================================== */ Net *B_create_net(id_num, file_name) int id_num; /* identificaion # of net */ char file_name[]; /* file with configuration of net */ /* ---------------------------------------------------------------------- The routine generates a net in the following way. As each Layer_spec is processed, a Layer is created but WITHOUT any connections to weight arrays. The trick is that the weight arrays cannot be made until all of the Layers are made! Thus as the layers are processed, an intermediate array of weight connections between layers is also generated. Then, when all the layers have been processed, this array of weight connections is traversed and the Weights are created. The array of weight connections (called 'wts_matrix') is a 2-d array whose first dimension represents SOURCE layers, and whose second dimension represents TARGET layers. If a SOURCE-to-TARGET weight connection exists, then the corresponding entry in the array will have the value 1; otherwize, the value is zero. The work of this routine is split up among subroutines: first, one named 'B_process_config' which creates the intermediate wts_matrix; then 'B_create_wts' which allocates space for the weights and sets up the pointers between the layers and weights; and finally 'B_setup_net' which sets up the values in the final net structure. Notice how 'result->ID' is initially set to -1. This translates to a bad net and is this routine's signal for returning an error. Thus if 'B_process_config' hits a snag in reading from the file, or if the file contains too many layer definitions, this routine can detect it and send a signal back to its caller. ---------------------------------------------------------------------- */ BEGIN int B_process_config(), B_create_wts(); void B_setup_net(); Net *result; /* the end product */ Layer_spec *wts_matrix[MAX_LAYERS][MAX_LAYERS]; /* for making wts */ Layer *layer_ptrs[MAX_LAYERS]; /* holds ptrs to layers */ int num_layers, i, j; /* actual # of layers */ result = (Net *) sys_alloc((unsigned)sizeof(Net)); result->ID = ERROR; result->num_layers = 0; result->input_layer = NULL; result->output_layer = NULL; result->hidden_front = NULL; result->hidden_back = NULL; result->use_biases = TRUE; result->num_inputs = 0; result->num_outputs = 0; result->num_io_pairs = 0; for (i = 0; i < MAX_LAYERS; i++) BEGIN /* initialize wts_matrix */ layer_ptrs[i] = NULL; /* and layer_ptrs array */ for (j = 0; j < MAX_LAYERS; j++) /* to all 'NULL' values */ wts_matrix[i][j] = NULL; ENDFOR if (B_process_config(file_name, wts_matrix, layer_ptrs, &num_layers) != OK) return(NULL); if (B_create_wts(wts_matrix, layer_ptrs, num_layers) != OK) return(NULL); B_setup_net(result, id_num, layer_ptrs, num_layers); return(result); END /* B_create_net */ int B_process_config(file_name, wts_matrix, layer_ptrs, ptr_num_layers) char file_name[]; Layer_spec *wts_matrix[]; Layer *layer_ptrs[]; int *ptr_num_layers; /* ---------------------------------------------------------------------- This guy processes the configuration passed in from the create_net routine above, creating Layers and the intermediate wt_matrix in the process. Two important notes. First, note that the last argument is a pointer to an int. I realize that this procedure could have been made a function which returned the value of the int, but nearly all of the incoming args get modified by this routine and so I chose to remain consistent in how the information calculated was passed back from this routine (namely, via the parameters themselves). Second, note that this guy opens the file specified by 'file_name' and then uses the routine 'PS_get_layer' to read in the specs for a file. Like the 'B_create_net' routine, the IO routine will return a negative number as one of the structure elements to indicate a problem in reading the file (ie, config->OK = ERROR). Aside from a reading error or an incomplete layer spec, this routine also will check for too many layers in the input file and return an error. By convention, routines will return an integer indicating an error, unless they must return a structure, in which case an element of the structure will be set to ERROR. This routine returns OK if everything goes ok. Otherwise, ERROR is returned. ---------------------------------------------------------------------- */ BEGIN FILE *fp; int i, DONE = FALSE; Layer_spec *config; if((fp = fopen(file_name, "rt")) == NULL) BEGIN sprintf(IO_str, "\n*** can't open file %s ***\n", file_name); IO_print(0); return(ERROR); ENDIF *ptr_num_layers = 0; /* initialize num_layers */ PS_reset_for_layer_parse(); if (PS_global_spec_check(fp) == ERROR) return(ERROR); config = PS_get_layer(fp); /* get first layer specs */ while ((DONE == FALSE) && (config->status != ERROR)) BEGIN if(*ptr_num_layers == MAX_LAYERS) BEGIN sprintf(IO_str, "\n*** too many layers ***\n"); IO_print(0); return(ERROR); ENDIF (*ptr_num_layers)++; layer_ptrs[config->ID] = L_alloc_layer(config); for (i = 0; i < config->num_targets; i++) wts_matrix[config->ID * MAX_LAYERS + config->targets[i][0]] = config; if (config->status == EOF) DONE = TRUE; else config = PS_get_layer(fp); ENDWHILE fclose(fp); if (config->status == ERROR) return(ERROR); else return(OK); END /* B_process_config */ int B_create_wts(wts_matrix, layer_ptrs, num_layers) Layer_spec *wts_matrix[]; Layer *layer_ptrs[]; int num_layers; /* ---------------------------------------------------------------------- Refer to comments under create_net. This routine takes the input array 'wts_matrix' and creates Weight structures with the appropriate information. It also links these structures into the corresponding lists within the Layer structures NOTE that no particular order is necessary when linking the weights into the Layers. Thus, new weights are simply inserted into the the front of the lists by using the 'W_insert_before' routine Returns OK if the weights can be created, ERROR otherwise. ---------------------------------------------------------------------- */ BEGIN Weights *new_wts; Weights_lst *new_wts_node; Layer *source, *target; Layer_spec *ptr_layer_spec; int i, j, B_check_layer_sizes(); if (B_check_layer_sizes(wts_matrix, layer_ptrs, num_layers) == ERROR) return(ERROR); for (i = 0; i < num_layers; i++) BEGIN source = layer_ptrs[i]; for (j = 0; j < num_layers; j++) BEGIN ptr_layer_spec = wts_matrix[i * MAX_LAYERS + j]; if (ptr_layer_spec != NULL) BEGIN target = layer_ptrs[j]; if ((source == NULL) || (target == NULL)) BEGIN sprintf(IO_str, "\n*** Warning: can't create weights between %d, %d ***", i, j); IO_print(0); sprintf(IO_str, "\n*** one of the layers was never created ***\n"); IO_print(0); ENDIF else BEGIN new_wts = W_alloc_weights(source, target, ptr_layer_spec); if (new_wts->type == ERROR) return(ERROR); new_wts_node = W_alloc_weights_lst(new_wts); source->out_weights = W_insert_before(new_wts_node, source->out_weights); new_wts_node = W_alloc_weights_lst(new_wts); target->in_weights = W_insert_before(new_wts_node, target->in_weights); ENDELSE ENDIF ENDFOR ENDFOR return(OK); END /* B_create_wts */ int B_check_layer_sizes(wts_matrix, layer_ptrs, num_layers) Layer_spec *wts_matrix[]; Layer *layer_ptrs[]; int num_layers; /* ---------------------------------------------------------------------- This routine checks through all of the layers, noting the layer with the most nodes. This number is then used to calculate the weight range for initializing the random weights. The whole concept for this routine comes from the formula for calculating the output of a node: output = f(SUM) where SUM = sum i,j [ Wij * Oi]. That is, you sum all of the incoming weight/output products, and the result is a sum fed through the semi linear activation function above. Problems arise if this SUM is much greater than 10 because the activation function starts to reach 0 or 1 at that point. Thus, we want to set our weights so that problem doesn't occur. Taking the worst case, we would have all of the output values "Oi" at .9, and all of the weights the same. That gives: 10 = .9 * (num_weights) * (weight value). Two conclusions can be drawn from the above. First, if you let the weights be as small as possible, you can find the maximum number of nodes allowable in a layer, since this program generates a weight for each node of a layer. That makes the maximum number of nodes about equal to 10 * 10^precision where 'precision' is equal to the the number of significant digits after the decimal point that the the Sint configuration allows (Thus for a Sint with 3 sig figs, you get a maximum layer size of 10 * 10^3 or 10,000). The second conclusion we can draw is that, given the maximum number of nodes in a layer, we can determine the range of values which the initial weights should have. That is what is done here. Note: this routine returns 0 if all goes well, otherwise 1. ---------------------------------------------------------------------- */ BEGIN int i, j, k; int max, temp; Layer_spec *ptr_layer_spec; Layer *source, *target; max = 0; /*----------------------------------------*/ /* find the maximum number of connections */ /* per node by looping through all the */ /* layer specs in the wts_matrix variable */ /*----------------------------------------*/ for (i = 0; i < num_layers; i++) BEGIN source = layer_ptrs[i]; for (j = 0; j < num_layers; j++) BEGIN ptr_layer_spec = wts_matrix[i * MAX_LAYERS + j]; if (ptr_layer_spec != NULL) BEGIN target = layer_ptrs[j]; /*----------------------------------------------------*/ /* find the corresponding target in the targets array */ /*----------------------------------------------------*/ for (k = 0; k < ptr_layer_spec->num_targets; k++) if (ptr_layer_spec->targets[k][0] == target->ID) break; /*----------------------------------*/ /* now we check the connection type */ /* by looking at targets array [0] */ /* if 0 (connect all) then the num */ /* of connections = source_nodes. */ /*----------------------------------*/ if (ptr_layer_spec->targets[k][1] == 0) temp = source->num_nodes; else /*-------------------------------------*/ /* if targets[k][0] != 0, then we have */ /* a patterned scheme. targets[1] and */ /* targets[2] hold P & Q, respecitvely */ /* and P * Q = num of connections */ /*-------------------------------------*/ temp = ptr_layer_spec->targets[k][1] * ptr_layer_spec->targets[k][2]; /*----------------------------------*/ /* use temp to set the max_incoming */ /* field of the TARGET layer */ /*----------------------------------*/ target->max_incoming = temp; max = ((temp > max) ? temp : max); ENDIF ENDFOR ENDFOR /*-----------------------------------*/ /* check the number of connections */ /* to see if it's too large for NETS */ /*-----------------------------------*/ if (max > MAX_NODES) BEGIN sprintf(IO_str, "\n*** Layers are too large; reduce the nodes in each layer to within %d ***\n", MAX_NODES); IO_print(0); return(ERROR); ENDIF W_weight_range(max); return(OK); END /* B_check_layer_sizes */ void B_setup_net(ptr_net, id_num, layer_ptrs, num_layers) Net *ptr_net; int id_num; Layer *layer_ptrs[]; int num_layers; /* ---------------------------------------------------------------------- This routine collects all the data created by the other two routines and assembles it into the net structure pointed to by 'ptr_net'. The final product is NOT a completely initialized net structure. The input/output pairs for learning are not yet present. There really is nothing hard going on here; most of the work has already been done at this point by 'B_process_config' and 'B_create_wts'. All that is left is to proceed through the layer_ptrs array and in- sert those layers into the net. Of course, the id, learn_rate, and momentum must also be set. Two notes: first, notice that the learn_rates and momentum must be con- verted into Sint format, since this is our internal representation for floating point numbers (see Sint in 'netpool.h'). Also, note that it is ASSUMED THAT THE LAYERS IN THE layer_ptrs ARRAY ARE IN THE ORDER THEY SHOULD BE COMPUTED. This assumption carries all the way back to the actual input, since that input is also assumed to be in the correct order (ie, nothing is done at ANY stage of the net creation to set an order). This is absolutely essential for the calculations on the net to be done correctly. Lastly, since order is so important, we cannot simply use an 'insert_before' routine for placing the layers into the net. Instead, we have to work BACKWARDS from the end of the array while using 'insert_before'. Also, note that at least two layers are assumed to be present in the array of layer pointers, namely the input and output layers. A net without at least these would be ridiculous anyway. By convention, these two layers are assumed to be layer 0 and 1, respectively, in the layer_ptrs array. Layers 0 and 1 ARE linked into the hidden list (even though they are not hidden) since they are both included included in the forward and backward propagation steps. Actually, layer 1 is included in forward prop, layer 0 in backward prop. Once all the layers have been linked into the hidden list, the two ends of the list are moved in by one. This is because we want the front of the list to point to the first layer of forward propagation, not layer 0. The same is true for backward propagation at the other end of the list. ---------------------------------------------------------------------- */ BEGIN void B_setup_learning(); Layer_lst *new_layer_node; int i; char tmp_str[MAX_WORD_SIZE]; /*-----------------------------------*/ /* if no input layer or output layer */ /* specified, then return error */ /*-----------------------------------*/ if (layer_ptrs[IN_LAYER] == 0) BEGIN sprintf(IO_str, "\n*** ERROR, no input layer ***\n"); IO_print(0); return; ENDIF if (layer_ptrs[OUT_LAYER] == 0) BEGIN sprintf(IO_str, "\n*** ERROR, no output layer ***\n"); IO_print(0); return; ENDIF /*----------------------*/ /* setup learning rates */ /*----------------------*/ B_setup_learning(layer_ptrs, num_layers); #if !DELIVERY /*------------------------------------------------*/ /* if not in delivery mode, prompt for bias value */ /*------------------------------------------------*/ sprintf(IO_str, "\n Use biases in network(y/n, default=y)? "); IO_print(0); IO_my_get_string(tmp_str); if (tmp_str[0] != ENDSTRING) if ( (tmp_str[0] == 'y') || (tmp_str[0] == 'Y') ) ptr_net->use_biases = TRUE; else ptr_net->use_biases = FALSE; #endif /*--------------------------------------*/ /* set the rest of the network elements */ /*--------------------------------------*/ ptr_net->ID = id_num; ptr_net->num_layers = num_layers; ptr_net->input_layer = layer_ptrs[IN_LAYER]; ptr_net->output_layer = layer_ptrs[OUT_LAYER]; /*-------------------------------------------*/ /* link the output layer to the hidden lists */ /*-------------------------------------------*/ ptr_net->hidden_back = L_alloc_layer_lst(layer_ptrs[OUT_LAYER]); ptr_net->hidden_front = L_insert_before(ptr_net->hidden_back, NULL); /*--------------------------------------*/ /* link the hidden layers into the list */ /*--------------------------------------*/ for (i = (num_layers-1); i > 1; i--) BEGIN new_layer_node = L_alloc_layer_lst(layer_ptrs[i]); ptr_net->hidden_front = L_insert_before(new_layer_node, ptr_net->hidden_front); ENDFOR /*-------------------------------------------*/ /* link the rest of the layers into the list */ /*-------------------------------------------*/ new_layer_node = L_alloc_layer_lst(layer_ptrs[IN_LAYER]); ptr_net->hidden_front = L_insert_before(new_layer_node, ptr_net->hidden_front); ptr_net->hidden_front = ptr_net->hidden_front->next; ptr_net->hidden_back = ptr_net->hidden_back->prev; END /* B_setup_net */ void B_setup_learning(layer_ptrs, num_layers) Layer *layer_ptrs[]; int num_layers; /* ---------------------------------------------------------------------- This routine loops through the layers twice. The first time it records the maximum number of weights found coming into any layer for calculating default values. This is done if global values were not specified by the user. Next, the second loop through the layers is performed so that all layers are given some learning rate and momentum. Two items are of note here. First, note that if the user does not enter a scale value then a default is NOT used here. Second, note that the "cur_learn" field IS NOT SET BEFORE THIS ROUTINE CALL. Thus, the second loop through the layers must be performed even if the global values were defined by the user (I had originally thought that this second loop could be skipped if both globals were already defined since the B_process_config routine would have already set the learn and momentum values base on the global defaults. But, alas, I forgot about the cur_learn field!). ---------------------------------------------------------------------- */ BEGIN void B_set_layer_learning(), B_set_layer_momentum(); int i, max_wts; Layer *cur_layer; /*------------------------------------------*/ /* loop through layers to find max weights */ /* then calc learning and momentum defaults */ /*------------------------------------------*/ max_wts = 0; for (i = 1; i < num_layers; i++) max_wts = (layer_ptrs[i]->max_incoming > max_wts) ? layer_ptrs[i]->max_incoming : max_wts; /*----------------------------------------*/ /* loop through all layers, setting the */ /* learn rate and momentum if not defined */ /*----------------------------------------*/ for (i = 1; i < num_layers; i++) BEGIN cur_layer = layer_ptrs[i]; B_set_layer_learning(cur_layer, max_wts); B_set_layer_momentum(cur_layer, max_wts); ENDFOR END /* B_setup_learning */ void B_set_layer_learning(ptr_layer, max_wts) Layer *ptr_layer; int max_wts; /* ---------------------------------------------------------------------- Given a pointer to a layer and the maximum weights connected to a node in the network, this routine goes through the motion of checking the state of the current layer to see if the user should be prompted for learning rates and/or scale values. Essentially, there are eight possible cases, depending upon the states of three values: the global learning base, the learn_base for the layer, and the learn_scale for the layer. The actions for these cases are as follows: (note that G = global_learn_base, L=layer learn_base, S=layer scale_base, and "N" means not defined, "Y" means defined) G L S Action taken ----- ------------ Y Y Y do nothing Y Y N set learn_scale = 0 Y N Y set learn_base = G Y N N set learn_base = G, set learn_scale = 0 N Y Y do nothing N Y N set learn_scale = 0 N N Y prompt for G/L; global default prompt for G, local for L N N N prompt for G/L/S; global for G, local for L, default for S,L Note that default values can be figured either on a global basis (using max_wts) or on a local basis based on the maximum incoming weights FOR THE LAYER. Also, a default scale can be figured from a learning rate and vice-versa when needed. Finally, note that this routine keeps track of a "prompt_state" variable so that it only prompts the user once to ask whether or not he/she wants a global learning rate. Using a static variable, one can reset its state every time a new net is created and its value will be retained between calls for each layer of a single network. ---------------------------------------------------------------------- */ BEGIN static float prompt_state = TRUE; float learn, scale; char tmp_str[MAX_WORD_SIZE]; /*--------------------------------------*/ /* reset the state of g_learn_state if */ /* we are starting a new network. If so */ /* then we will be starting w/layer 1 */ /*--------------------------------------*/ if (ptr_layer->ID == 1) prompt_state = TRUE; /*-------------------------------------------*/ /* handles the top half of the table in the */ /* comment, setting the learning base to the */ /* global learning rate and the learing rate */ /* to 0 (zero) if it's undefined. */ /*-------------------------------------------*/ if (global_learn_base != UNDEFINED) BEGIN if (ptr_layer->learn_base == UNDEFINED) ptr_layer->learn_base = global_learn_base; if (ptr_layer->learn_scale == UNDEFINED) ptr_layer->learn_scale = 0; ENDIF else BEGIN /*--------------------------------------------------*/ /* handle cases 5 and 6 of the table in the comment */ /* In these cases, just set the scale if undefined */ /*--------------------------------------------------*/ if (ptr_layer->learn_base != UNDEFINED) BEGIN if (ptr_layer->learn_scale == UNDEFINED) ptr_layer->learn_scale = 0; ENDIF else BEGIN /*----------------------------------------*/ /* for the last two cases, if user hasn't */ /* been prompted for global, then prompt */ /*----------------------------------------*/ if (prompt_state == TRUE) BEGIN prompt_state = FALSE; sprintf(IO_str, "\n Use a global learning rate (y/n, default=y)? "); IO_print(0); IO_my_get_string(tmp_str); if ((tmp_str[0] == ENDSTRING) || (tmp_str[0] == 'y') || (tmp_str[0] == 'Y')) BEGIN /*-------------------------------------*/ /* if global is selected, then prompt */ /* and use value as default learn rate */ /*-------------------------------------*/ learn = LR_learn_default(max_wts); sprintf(IO_wkstr, "\n Enter global learning rate (default=%%.f): "); IO_insert_format(IO_wkstr); sprintf(IO_str, IO_wkstr, learn); IO_print(0); global_learn_base = IO_get_default_float(learn); ptr_layer->learn_base = global_learn_base; if (ptr_layer->learn_scale == UNDEFINED) ptr_layer->learn_scale = 0; ENDIF ENDIF /*----------------------------------------------*/ /* if the global is still undefined, that means */ /* the user has elected against a global learn */ /*----------------------------------------------*/ if (global_learn_base == UNDEFINED) BEGIN /*---------------------------------------*/ /* first, prompt for default learn value */ /*---------------------------------------*/ if (ptr_layer->learn_scale == UNDEFINED) BEGIN learn = LR_learn_default(ptr_layer->max_incoming); sprintf(IO_str, "\n Use constant learning rate for layer "); IO_print(0); sprintf(IO_str, "%d (y/n, default=y)? ", ptr_layer->ID); IO_print(0); IO_my_get_string(tmp_str); /*-----------------------------------------*/ /* if denied, then the user wants a varied */ /* learning rate. Divide default by 2. If */ /* "y", the constant learn; set scale = 0. */ /*-----------------------------------------*/ if ((tmp_str[0] != ENDSTRING) && (tmp_str[0] != 'y') && (tmp_str[0] != 'Y')) learn = learn / 2.0; else ptr_layer->learn_scale = 0; ENDIF else learn = LR_learn_from_scale(ptr_layer->learn_scale); /*-----------------------------------------------*/ /* prompt for the learning rate based on default */ /*-----------------------------------------------*/ sprintf(IO_str, "\n Enter learning rate for layer "); IO_print(0); sprintf(IO_wkstr, "%d (default=%%.f): ", ptr_layer->ID); IO_insert_format(IO_wkstr); sprintf(IO_str, IO_wkstr, learn); IO_print(0); ptr_layer->learn_base = IO_get_default_float(learn); /*-------------------------------------*/ /* finally, prompt for the learn_scale */ /* if it is undefined at this point */ /*-------------------------------------*/ if (ptr_layer->learn_scale == UNDEFINED) BEGIN scale = LR_scale_default(ptr_layer->learn_base); sprintf(IO_str, "\n Enter scaling factor for layer "); IO_print(0); sprintf(IO_wkstr, "%d (default=%%.f): ", ptr_layer->ID); IO_insert_format(IO_wkstr); sprintf(IO_str, IO_wkstr, scale); IO_print(0); ptr_layer->learn_scale = IO_get_default_float(scale); ENDIF ENDIF ENDELSE ENDELSE /*-------------------------------------*/ /* when the dust clears, set the first */ /* learning rate value for the layer */ /*-------------------------------------*/ ptr_layer->cur_learn = (D_Sint)C_float_to_Sint(ptr_layer->learn_base); END /* B_set_layer_learning */ void B_set_layer_momentum(ptr_layer, max_wts) Layer *ptr_layer; int max_wts; /* ---------------------------------------------------------------------- Sets the momentum value for the layer, given a pointer to the layer and the maximum weights connected into a node in the network. There are four cases which must be handled, based on the values of the global momentum (G) and the local momentum defined for the layer (M). The table below gives the appropriate actions for the four states, based upon whether or not G,M are specified ("Y") or not ("N"): G M Action --- ------- Y Y do nothing Y N set momemtum = G N Y do nothing N N prompt for global G, set momentum to G or prompt for local. As with the B_set_layer_learning routine, the last case prompts the user for a global momentum ONLY ONCE by keeping track of a local static variable on the prompt_state. ---------------------------------------------------------------------- */ BEGIN static float prompt_state = TRUE; float momentum; char tmp_str[MAX_WORD_SIZE]; /*--------------------------------------*/ /* reset the state of g_learn_state if */ /* we are starting a new network. If so */ /* then we will be starting w/layer 1 */ /*--------------------------------------*/ if (ptr_layer->ID == 1) prompt_state = TRUE; if (ptr_layer->momentum == UNDEFINED) BEGIN /*------------------------------------------*/ /* if user hasn't been prompted, then do so */ /*------------------------------------------*/ if ((prompt_state == TRUE) && (global_momentum == UNDEFINED)) BEGIN prompt_state = FALSE; sprintf(IO_str, "\n Use a global momentum (y/n, default=y)? "); IO_print(0); IO_my_get_string(tmp_str); if ((tmp_str[0] == ENDSTRING) || (tmp_str[0] == 'y') || (tmp_str[0] == 'Y')) BEGIN /*-------------------------------------*/ /* if global is selected, then prompt */ /* and use value as default momentum */ /*-------------------------------------*/ momentum = LR_momentum_default(max_wts); sprintf(IO_wkstr, "\n Enter global momentum (default=%%.f): "); IO_insert_format(IO_wkstr); sprintf(IO_str, IO_wkstr, momentum); IO_print(0); global_momentum = IO_get_default_float(momentum); ENDIF ENDIF if (global_momentum != UNDEFINED) ptr_layer->momentum = global_momentum; else BEGIN /*---------------------------------------------*/ /* if global undefined, then local momentum */ /* is desired. Calc default using max incoming */ /*---------------------------------------------*/ momentum = LR_momentum_default(ptr_layer->max_incoming); sprintf(IO_str, "\n Enter momentum for layer "); IO_print(0); sprintf(IO_str, "%d (default=%%.f): ", ptr_layer->ID); IO_insert_format(IO_wkstr); sprintf(IO_str, IO_wkstr, momentum); IO_print(0); ptr_layer->momentum = IO_get_default_float(momentum); ENDELSE ENDIF END /* B_set_layer_momentum */ Net *B_free_net(ptr_net) Net *ptr_net; /* ---------------------------------------------------------------------- The purpose of this routine is memory management. It frees the memory allocated to a network specified by the network pointer and resets the pointer to NULL. To accomplish this task, this routine passes the buck to the L_free_layer_lst routine which simply loops through all of the layers of the network calling L_free_layer for each. Note that the weights are doubly referenced and can thus cause a problem. To avoid freeing something twice, I use the convention of freeing only a layer's INCOMING weights. This means that the INPUT LAYER can be SKIPPED by this routine( see L_free_layer_lst for details ). NOTE: The OUTPUT layer is included in the list of hidden layers. Recall that the list "hidden_front" includes all those layers which must be updated for a forward propagation. This includes the output layer. Thus there is an implicit freeing of the output layer when the hidden layers are freed. ---------------------------------------------------------------------- */ BEGIN if (ptr_net == NULL) return(NULL); L_free_layer(ptr_net->input_layer); L_free_layer_lst(ptr_net->hidden_front); sys_free((char *)ptr_net); return(NULL); END /* B_free_net */