X-Git-Url: https://ruin.nu/git/?p=germs.git;a=blobdiff_plain;f=fann%2Fsrc%2Finclude%2Ffann_data.h;fp=fann%2Fsrc%2Finclude%2Ffann_data.h;h=f2afa23d099d6fee5efd5fc0fd5f9d933558dc59;hp=0000000000000000000000000000000000000000;hb=40d817fd1c0ec184927450858ca95b722ae8acba;hpb=0ced9c229cf05fa677686df27eca9f167f11a87f diff --git a/fann/src/include/fann_data.h b/fann/src/include/fann_data.h new file mode 100644 index 0000000..f2afa23 --- /dev/null +++ b/fann/src/include/fann_data.h @@ -0,0 +1,673 @@ +/* +Fast Artificial Neural Network Library (fann) +Copyright (C) 2003 Steffen Nissen (lukesky@diku.dk) + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library; if not, write to the Free Software +Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +*/ + +#ifndef __fann_data_h__ +#define __fann_data_h__ + +#include + +/* Section: FANN Datatypes + + The two main datatypes used in the fann library is , + which represents an artificial neural network, and , + which represent training data. + */ + + +/* Type: fann_type + fann_type is the type used for the weights, inputs and outputs of the neural network. + + fann_type is defined as a: + float - if you include fann.h or floatfann.h + double - if you include doublefann.h + int - if you include fixedfann.h (please be aware that fixed point usage is + only to be used during execution, and not during training). +*/ + +/* Enum: fann_train_enum + The Training algorithms used when training on with functions like + or . The incremental training looks alters the weights + after each time it is presented an input pattern, while batch only alters the weights once after + it has been presented to all the patterns. + + FANN_TRAIN_INCREMENTAL - Standard backpropagation algorithm, where the weights are + updated after each training pattern. This means that the weights are updated many + times during a single epoch. For this reason some problems, will train very fast with + this algorithm, while other more advanced problems will not train very well. + FANN_TRAIN_BATCH - Standard backpropagation algorithm, where the weights are updated after + calculating the mean square error for the whole training set. This means that the weights + are only updated once during a epoch. For this reason some problems, will train slower with + this algorithm. But since the mean square error is calculated more correctly than in + incremental training, some problems will reach a better solutions with this algorithm. + FANN_TRAIN_RPROP - A more advanced batch training algorithm which achieves good results + for many problems. The RPROP training algorithm is adaptive, and does therefore not + use the learning_rate. Some other parameters can however be set to change the way the + RPROP algorithm works, but it is only recommended for users with insight in how the RPROP + training algorithm works. The RPROP training algorithm is described by + [Riedmiller and Braun, 1993], but the actual learning algorithm used here is the + iRPROP- training algorithm which is described by [Igel and Husken, 2000] which + is an variety of the standard RPROP training algorithm. + FANN_TRAIN_QUICKPROP - A more advanced batch training algorithm which achieves good results + for many problems. The quickprop training algorithm uses the learning_rate parameter + along with other more advanced parameters, but it is only recommended to change these + advanced parameters, for users with insight in how the quickprop training algorithm works. + The quickprop training algorithm is described by [Fahlman, 1988]. + + See also: + , +*/ +enum fann_train_enum +{ + FANN_TRAIN_INCREMENTAL = 0, + FANN_TRAIN_BATCH, + FANN_TRAIN_RPROP, + FANN_TRAIN_QUICKPROP +}; + +/* Constant: FANN_TRAIN_NAMES + + Constant array consisting of the names for the training algorithms, so that the name of an + training function can be received by: + (code) + char *name = FANN_TRAIN_NAMES[train_function]; + (end) + + See Also: + +*/ +static char const *const FANN_TRAIN_NAMES[] = { + "FANN_TRAIN_INCREMENTAL", + "FANN_TRAIN_BATCH", + "FANN_TRAIN_RPROP", + "FANN_TRAIN_QUICKPROP" +}; + +/* Enums: fann_activationfunc_enum + + The activation functions used for the neurons during training. The activation functions + can either be defined for a group of neurons by and + or it can be defined for a single neuron by . + + The steepness of an activation function is defined in the same way by + , and . + + The functions are described with functions where: + * x is the input to the activation function, + * y is the output, + * s is the steepness and + * d is the derivation. + + FANN_LINEAR - Linear activation function. + * span: -inf < y < inf + * y = x*s, d = 1*s + * Can NOT be used in fixed point. + + FANN_THRESHOLD - Threshold activation function. + * x < 0 -> y = 0, x >= 0 -> y = 1 + * Can NOT be used during training. + + FANN_THRESHOLD_SYMMETRIC - Threshold activation function. + * x < 0 -> y = 0, x >= 0 -> y = 1 + * Can NOT be used during training. + + FANN_SIGMOID - Sigmoid activation function. + * One of the most used activation functions. + * span: 0 < y < 1 + * y = 1/(1 + exp(-2*s*x)) + * d = 2*s*y*(1 - y) + + FANN_SIGMOID_STEPWISE - Stepwise linear approximation to sigmoid. + * Faster than sigmoid but a bit less precise. + + FANN_SIGMOID_SYMMETRIC - Symmetric sigmoid activation function, aka. tanh. + * One of the most used activation functions. + * span: -1 < y < 1 + * y = tanh(s*x) = 2/(1 + exp(-2*s*x)) - 1 + * d = s*(1-(y*y)) + + FANN_SIGMOID_SYMMETRIC - Stepwise linear approximation to symmetric sigmoid. + * Faster than symmetric sigmoid but a bit less precise. + + FANN_GAUSSIAN - Gaussian activation function. + * 0 when x = -inf, 1 when x = 0 and 0 when x = inf + * span: 0 < y < 1 + * y = exp(-x*s*x*s) + * d = -2*x*s*y*s + + FANN_GAUSSIAN_SYMMETRIC - Symmetric gaussian activation function. + * -1 when x = -inf, 1 when x = 0 and 0 when x = inf + * span: -1 < y < 1 + * y = exp(-x*s*x*s)*2-1 + * d = -2*x*s*(y+1)*s + + FANN_ELLIOT - Fast (sigmoid like) activation function defined by David Elliott + * span: 0 < y < 1 + * y = ((x*s) / 2) / (1 + |x*s|) + 0.5 + * d = s*1/(2*(1+|x*s|)*(1+|x*s|)) + + FANN_ELLIOT_SYMMETRIC - Fast (symmetric sigmoid like) activation function defined by David Elliott + * span: -1 < y < 1 + * y = (x*s) / (1 + |x*s|) + * d = s*1/((1+|x*s|)*(1+|x*s|)) + + FANN_LINEAR_PIECE - Bounded linear activation function. + * span: 0 < y < 1 + * y = x*s, d = 1*s + + FANN_LINEAR_PIECE_SYMMETRIC - Bounded Linear activation function. + * span: -1 < y < 1 + * y = x*s, d = 1*s + + See also: + , + +*/ +enum fann_activationfunc_enum +{ + FANN_LINEAR = 0, + FANN_THRESHOLD, + FANN_THRESHOLD_SYMMETRIC, + FANN_SIGMOID, + FANN_SIGMOID_STEPWISE, + FANN_SIGMOID_SYMMETRIC, + FANN_SIGMOID_SYMMETRIC_STEPWISE, + FANN_GAUSSIAN, + FANN_GAUSSIAN_SYMMETRIC, + /* Stepwise linear approximation to gaussian. + * Faster than gaussian but a bit less precise. + * NOT implemented yet. + */ + FANN_GAUSSIAN_STEPWISE, + FANN_ELLIOT, + FANN_ELLIOT_SYMMETRIC, + FANN_LINEAR_PIECE, + FANN_LINEAR_PIECE_SYMMETRIC +}; + +/* Constant: FANN_ACTIVATIONFUNC_NAMES + + Constant array consisting of the names for the activation function, so that the name of an + activation function can be received by: + (code) + char *name = FANN_ACTIVATIONFUNC_NAMES[activation_function]; + (end) + + See Also: + +*/ +static char const *const FANN_ACTIVATIONFUNC_NAMES[] = { + "FANN_LINEAR", + "FANN_THRESHOLD", + "FANN_THRESHOLD_SYMMETRIC", + "FANN_SIGMOID", + "FANN_SIGMOID_STEPWISE", + "FANN_SIGMOID_SYMMETRIC", + "FANN_SIGMOID_SYMMETRIC_STEPWISE", + "FANN_GAUSSIAN", + "FANN_GAUSSIAN_SYMMETRIC", + "FANN_GAUSSIAN_STEPWISE", + "FANN_ELLIOT", + "FANN_ELLIOT_SYMMETRIC", + "FANN_LINEAR_PIECE", + "FANN_LINEAR_PIECE_SYMMETRIC" +}; + +/* Enum: fann_errorfunc_enum + Error function used during training. + + FANN_ERRORFUNC_LINEAR - Standard linear error function. + FANN_ERRORFUNC_TANH - Tanh error function, usually better + but can require a lower learning rate. This error function agressively targets outputs that + differ much from the desired, while not targetting outputs that only differ a little that much. + This activation function is not recommended for cascade training and incremental training. + + See also: + , +*/ +enum fann_errorfunc_enum +{ + FANN_ERRORFUNC_LINEAR = 0, + FANN_ERRORFUNC_TANH +}; + +/* Constant: FANN_ERRORFUNC_NAMES + + Constant array consisting of the names for the training error functions, so that the name of an + error function can be received by: + (code) + char *name = FANN_ERRORFUNC_NAMES[error_function]; + (end) + + See Also: + +*/ +static char const *const FANN_ERRORFUNC_NAMES[] = { + "FANN_ERRORFUNC_LINEAR", + "FANN_ERRORFUNC_TANH" +}; + +/* Enum: fann_stopfunc_enum + Stop criteria used during training. + + FANN_STOPFUNC_MSE - Stop criteria is Mean Square Error (MSE) value. + FANN_STOPFUNC_BIT - Stop criteria is number of bits that fail. The number of bits; means the + number of output neurons which differ more than the bit fail limit + (see , ). + The bits are counted in all of the training data, so this number can be higher than + the number of training data. + + See also: + , +*/ +enum fann_stopfunc_enum +{ + FANN_STOPFUNC_MSE = 0, + FANN_STOPFUNC_BIT +}; + +/* Constant: FANN_STOPFUNC_NAMES + + Constant array consisting of the names for the training stop functions, so that the name of a + stop function can be received by: + (code) + char *name = FANN_STOPFUNC_NAMES[stop_function]; + (end) + + See Also: + +*/ +static char const *const FANN_STOPFUNC_NAMES[] = { + "FANN_STOPFUNC_MSE", + "FANN_STOPFUNC_BIT" +}; + +/* forward declarations for use with the callback */ +struct fann; +struct fann_train_data; +/* Type: fann_callback_type + This callback function can be called during training when using , + or . + + >typedef int (FANN_API * fann_callback_type) (struct fann *ann, struct fann_train_data *train, + > unsigned int max_epochs, + > unsigned int epochs_between_reports, + > float desired_error, unsigned int epochs); + + The callback can be set by using and is very usefull for doing custom + things during training. It is recommended to use this function when implementing custom + training procedures, or when visualizing the training in a GUI etc. The parameters which the + callback function takes is the parameters given to the , plus an epochs + parameter which tells how many epochs the training have taken so far. + + The callback function should return an integer, if the callback function returns -1, the training + will terminate. + + Example of a callback function: + >int FANN_API test_callback(struct fann *ann, struct fann_train_data *train, + > unsigned int max_epochs, unsigned int epochs_between_reports, + > float desired_error, unsigned int epochs) + >{ + > printf("Epochs %8d. MSE: %.5f. Desired-MSE: %.5f\n", epochs, fann_get_MSE(ann), desired_error); + > return 0; + >} + + See also: + , + */ +FANN_EXTERNAL typedef int (FANN_API * fann_callback_type) (struct fann *ann, struct fann_train_data *train, + unsigned int max_epochs, + unsigned int epochs_between_reports, + float desired_error, unsigned int epochs); + + +/* ----- Data structures ----- + * No data within these structures should be altered directly by the user. + */ + +struct fann_neuron +{ + /* Index to the first and last connection + * (actually the last is a past end index) + */ + unsigned int first_con; + unsigned int last_con; + /* The sum of the inputs multiplied with the weights */ + fann_type sum; + /* The value of the activation function applied to the sum */ + fann_type value; + /* The steepness of the activation function */ + fann_type activation_steepness; + /* Used to choose which activation function to use */ + enum fann_activationfunc_enum activation_function; +#ifdef __GNUC__ +} __attribute__ ((packed)); +#else +}; +#endif + +/* A single layer in the neural network. + */ +struct fann_layer +{ + /* A pointer to the first neuron in the layer + * When allocated, all the neurons in all the layers are actually + * in one long array, this is because we wan't to easily clear all + * the neurons at once. + */ + struct fann_neuron *first_neuron; + + /* A pointer to the neuron past the last neuron in the layer */ + /* the number of neurons is last_neuron - first_neuron */ + struct fann_neuron *last_neuron; +}; + +/* Struct: struct fann_error + + Structure used to store error-related information, both + and can be casted to this type. + + See also: + , +*/ +struct fann_error +{ + enum fann_errno_enum errno_f; + FILE *error_log; + char *errstr; +}; + + +/* Struct: struct fann + The fast artificial neural network(fann) structure. + + Data within this structure should never be accessed directly, but only by using the + *fann_get_...* and *fann_set_...* functions. + + The fann structure is created using one of the *fann_create_...* functions and each of + the functions which operates on the structure takes *struct fann * ann* as the first parameter. + + See also: + , + */ +struct fann +{ + /* The type of error that last occured. */ + enum fann_errno_enum errno_f; + + /* Where to log error messages. */ + FILE *error_log; + + /* A string representation of the last error. */ + char *errstr; + + /* the learning rate of the network */ + float learning_rate; + + /* The learning momentum used for backpropagation algorithm. */ + float learning_momentum; + + /* the connection rate of the network + * between 0 and 1, 1 meaning fully connected + */ + float connection_rate; + + /* is 1 if shortcut connections are used in the ann otherwise 0 + * Shortcut connections are connections that skip layers. + * A fully connected ann with shortcut connections are a ann where + * neurons have connections to all neurons in all later layers. + */ + unsigned int shortcut_connections; + + /* pointer to the first layer (input layer) in an array af all the layers, + * including the input and outputlayers + */ + struct fann_layer *first_layer; + + /* pointer to the layer past the last layer in an array af all the layers, + * including the input and outputlayers + */ + struct fann_layer *last_layer; + + /* Total number of neurons. + * very usefull, because the actual neurons are allocated in one long array + */ + unsigned int total_neurons; + + /* Number of input neurons (not calculating bias) */ + unsigned int num_input; + + /* Number of output neurons (not calculating bias) */ + unsigned int num_output; + + /* The weight array */ + fann_type *weights; + + /* The connection array */ + struct fann_neuron **connections; + + /* Used to contain the errors used during training + * Is allocated during first training session, + * which means that if we do not train, it is never allocated. + */ + fann_type *train_errors; + + /* Training algorithm used when calling fann_train_on_.. + */ + enum fann_train_enum training_algorithm; + +#ifdef FIXEDFANN + /* the decimal_point, used for shifting the fix point + * in fixed point integer operatons. + */ + unsigned int decimal_point; + + /* the multiplier, used for multiplying the fix point + * in fixed point integer operatons. + * Only used in special cases, since the decimal_point is much faster. + */ + unsigned int multiplier; + + /* When in choosen (or in fixed point), the sigmoid function is + * calculated as a stepwise linear function. In the + * activation_results array, the result is saved, and in the + * two values arrays, the values that gives the results are saved. + */ + fann_type sigmoid_results[6]; + fann_type sigmoid_values[6]; + fann_type sigmoid_symmetric_results[6]; + fann_type sigmoid_symmetric_values[6]; +#endif + + /* Total number of connections. + * very usefull, because the actual connections + * are allocated in one long array + */ + unsigned int total_connections; + + /* used to store outputs in */ + fann_type *output; + + /* the number of data used to calculate the mean square error. + */ + unsigned int num_MSE; + + /* the total error value. + * the real mean square error is MSE_value/num_MSE + */ + float MSE_value; + + /* The number of outputs which would fail (only valid for classification problems) + */ + unsigned int num_bit_fail; + + /* The maximum difference between the actual output and the expected output + * which is accepted when counting the bit fails. + * This difference is multiplied by two when dealing with symmetric activation functions, + * so that symmetric and not symmetric activation functions can use the same limit. + */ + fann_type bit_fail_limit; + + /* The error function used during training. (default FANN_ERRORFUNC_TANH) + */ + enum fann_errorfunc_enum train_error_function; + + /* The stop function used during training. (default FANN_STOPFUNC_MSE) + */ + enum fann_stopfunc_enum train_stop_function; + + /* The callback function used during training. (default NULL) + */ + fann_callback_type callback; + + /* Variables for use with Cascade Correlation */ + + /* The error must change by at least this + * fraction of its old value to count as a + * significant change. + */ + float cascade_output_change_fraction; + + /* No change in this number of epochs will cause + * stagnation. + */ + unsigned int cascade_output_stagnation_epochs; + + /* The error must change by at least this + * fraction of its old value to count as a + * significant change. + */ + float cascade_candidate_change_fraction; + + /* No change in this number of epochs will cause + * stagnation. + */ + unsigned int cascade_candidate_stagnation_epochs; + + /* The current best candidate, which will be installed. + */ + unsigned int cascade_best_candidate; + + /* The upper limit for a candidate score + */ + fann_type cascade_candidate_limit; + + /* Scale of copied candidate output weights + */ + fann_type cascade_weight_multiplier; + + /* Maximum epochs to train the output neurons during cascade training + */ + unsigned int cascade_max_out_epochs; + + /* Maximum epochs to train the candidate neurons during cascade training + */ + unsigned int cascade_max_cand_epochs; + + /* An array consisting of the activation functions used when doing + * cascade training. + */ + enum fann_activationfunc_enum *cascade_activation_functions; + + /* The number of elements in the cascade_activation_functions array. + */ + unsigned int cascade_activation_functions_count; + + /* An array consisting of the steepnesses used during cascade training. + */ + fann_type *cascade_activation_steepnesses; + + /* The number of elements in the cascade_activation_steepnesses array. + */ + unsigned int cascade_activation_steepnesses_count; + + /* The number of candidates of each type that will be present. + * The actual number of candidates is then + * cascade_activation_functions_count * + * cascade_activation_steepnesses_count * + * cascade_num_candidate_groups + */ + unsigned int cascade_num_candidate_groups; + + /* An array consisting of the score of the individual candidates, + * which is used to decide which candidate is the best + */ + fann_type *cascade_candidate_scores; + + /* The number of allocated neurons during cascade correlation algorithms. + * This number might be higher than the actual number of neurons to avoid + * allocating new space too often. + */ + unsigned int total_neurons_allocated; + + /* The number of allocated connections during cascade correlation algorithms. + * This number might be higher than the actual number of neurons to avoid + * allocating new space too often. + */ + unsigned int total_connections_allocated; + + /* Variables for use with Quickprop training */ + + /* Decay is used to make the weights not go so high */ + float quickprop_decay; + + /* Mu is a factor used to increase and decrease the stepsize */ + float quickprop_mu; + + /* Variables for use with with RPROP training */ + + /* Tells how much the stepsize should increase during learning */ + float rprop_increase_factor; + + /* Tells how much the stepsize should decrease during learning */ + float rprop_decrease_factor; + + /* The minimum stepsize */ + float rprop_delta_min; + + /* The maximum stepsize */ + float rprop_delta_max; + + /* The initial stepsize */ + float rprop_delta_zero; + + /* Used to contain the slope errors used during batch training + * Is allocated during first training session, + * which means that if we do not train, it is never allocated. + */ + fann_type *train_slopes; + + /* The previous step taken by the quickprop/rprop procedures. + * Not allocated if not used. + */ + fann_type *prev_steps; + + /* The slope values used by the quickprop/rprop procedures. + * Not allocated if not used. + */ + fann_type *prev_train_slopes; + + /* The last delta applied to a connection weight. + * This is used for the momentum term in the backpropagation algorithm. + * Not allocated if not used. + */ + fann_type *prev_weights_deltas; + +}; + +#endif