Index

F |
| FANN
| FANN Cascade Training
| FANN Creation/Execution
| FANN Datatypes
| FANN Error Handling
| FANN File Input/Output
| FANN Training
| FANN Wrapper for C++
| fann_activationfunc_enum
| FANN_ACTIVATIONFUNC_NAMES
| fann_callback_type
| fann_cascadetrain_on_data
| fann_cascadetrain_on_file
| fann_clear_scaling_params
| fann_connection, struct fann
| FANN_COS
| FANN_COS_SYMMETRIC Global FANN
| fann_create_from_file
| fann_create_shortcut
| fann_create_shortcut_array
| fann_create_sparse
| fann_create_sparse_array
| fann_create_standard
| fann_create_standard_array
| fann_create_train_from_callback
| fann_descale_input
| fann_descale_output
| fann_descale_train
| fann_destroy
| fann_destroy_train
| fann_duplicate_train_data
| FANN_E_CANT_ALLOCATE_MEM
| FANN_E_CANT_OPEN_CONFIG_R
| FANN_E_CANT_OPEN_CONFIG_W
| FANN_E_CANT_OPEN_TD_R
| FANN_E_CANT_OPEN_TD_W
| FANN_E_CANT_READ_CONFIG
| FANN_E_CANT_READ_CONNECTIONS
| FANN_E_CANT_READ_NEURON
| FANN_E_CANT_READ_TD
| FANN_E_CANT_TRAIN_ACTIVATION
| FANN_E_CANT_USE_ACTIVATION
| FANN_E_CANT_USE_TRAIN_ALG
| FANN_E_INDEX_OUT_OF_BOUND
| FANN_E_NO_ERROR
| FANN_E_SCALE_NOT_PRESENT
| FANN_E_TRAIN_DATA_MISMATCH
| FANN_E_TRAIN_DATA_SUBSET
| FANN_E_WRONG_CONFIG_VERSION
| FANN_E_WRONG_NUM_CONNECTIONS
| FANN_ELLIOT Global FANN
| FANN_ELLIOT_SYMMETRIC Global FANN
| fann_errno_enum
| fann_errorfunc_enum
| FANN_ERRORFUNC_LINEAR
| FANN_ERRORFUNC_NAMES
| FANN_ERRORFUNC_TANH
| FANN_GAUSSIAN Global FANN
| FANN_GAUSSIAN_SYMMETRIC Global FANN
| fann_get_activation_function
| fann_get_activation_steepness
| fann_get_bias_array
| fann_get_bit_fail
| fann_get_bit_fail_limit
| fann_get_cascade_activation_functions
| fann_get_cascade_activation_functions_count
| fann_get_cascade_activation_steepnesses
| fann_get_cascade_activation_steepnesses_count
| fann_get_cascade_candidate_change_fraction
| fann_get_cascade_candidate_limit
| fann_get_cascade_candidate_stagnation_epochs
| fann_get_cascade_max_cand_epochs
| fann_get_cascade_max_out_epochs
| fann_get_cascade_num_candidate_groups
| fann_get_cascade_num_candidates
| fann_get_cascade_output_change_fraction
| fann_get_cascade_output_stagnation_epochs
| fann_get_cascade_weight_multiplier
| fann_get_connection_array
| fann_get_connection_rate
| fann_get_decimal_point
| fann_get_errno
| fann_get_errstr
| fann_get_layer_array
| fann_get_learning_momentum
| fann_get_learning_rate
| fann_get_MSE
| fann_get_multiplier
| fann_get_network_type
| fann_get_num_input
| fann_get_num_layers
| fann_get_num_output
| fann_get_quickprop_decay
| fann_get_quickprop_mu
| fann_get_rprop_decrease_factor
| fann_get_rprop_delta_max
| fann_get_rprop_delta_min
| fann_get_rprop_delta_zero
| fann_get_rprop_increase_factor
| fann_get_total_connections
| fann_get_total_neurons
| fann_get_train_error_function
| fann_get_train_stop_function
| fann_get_training_algorithm
| fann_get_user_data
| fann_init_weights
| fann_length_train_data
| FANN_LINEAR Global FANN
| FANN_LINEAR_PIECE Global FANN
| FANN_LINEAR_PIECE_SYMMETRIC Global FANN
| fann_merge_train_data
| FANN_NETTYPE_LAYER
| FANN_NETTYPE_SHORTCUT
| fann_network_type_enum
| FANN_NETWORK_TYPE_NAMES
| fann_num_input_train_data
| fann_num_output_train_data
| fann_print_connections
| fann_print_error
| fann_print_parameters
| fann_randomize_weights
| fann_read_train_from_file
| fann_reset_errno
| fann_reset_errstr
| fann_reset_MSE
| fann_run
| fann_save
| fann_save_to_fixed
| fann_save_train
| fann_save_train_to_fixed
| fann_scale_input
| fann_scale_input_train_data
| fann_scale_output
| fann_scale_output_train_data
| fann_scale_train
| fann_scale_train_data
| fann_set_activation_function
| fann_set_activation_function_hidden
| fann_set_activation_function_layer
| fann_set_activation_function_output
| fann_set_activation_steepness
| fann_set_activation_steepness_hidden
| fann_set_activation_steepness_layer
| fann_set_activation_steepness_output
| fann_set_bit_fail_limit
| fann_set_callback
| fann_set_cascade_activation_functions
| fann_set_cascade_activation_steepnesses
| fann_set_cascade_candidate_change_fraction
| fann_set_cascade_candidate_limit
| fann_set_cascade_candidate_stagnation_epochs
| fann_set_cascade_max_cand_epochs
| fann_set_cascade_max_out_epochs
| fann_set_cascade_num_candidate_groups
| fann_set_cascade_output_change_fraction
| fann_set_cascade_output_stagnation_epochs
| fann_set_cascade_weight_multiplier
| fann_set_error_log
| fann_set_input_scaling_params
| fann_set_learning_momentum
| fann_set_learning_rate
| fann_set_output_scaling_params
| fann_set_quickprop_decay
| fann_set_quickprop_mu
| fann_set_rprop_decrease_factor
| fann_set_rprop_delta_max
| fann_set_rprop_delta_min
| fann_set_rprop_delta_zero
| fann_set_rprop_increase_factor
| fann_set_scaling_params
| fann_set_train_error_function
| fann_set_train_stop_function
| fann_set_training_algorithm
| fann_set_user_data
| fann_set_weight
| fann_set_weight_array
| fann_shuffle_train_data
| FANN_SIGMOID Global FANN
| FANN_SIGMOID_STEPWISE Global FANN
| FANN_SIGMOID_SYMMETRIC Global FANN
| FANN_SIN
| FANN_SIN_SYMMETRIC Global FANN
| FANN_STOPFUNC_BIT
| fann_stopfunc_enum
| FANN_STOPFUNC_MSE
| FANN_STOPFUNC_NAMES
| fann_subset_train_data
| fann_test
| fann_test_data
| FANN_THRESHOLD Global FANN
| FANN_THRESHOLD_SYMMETRIC Global FANN
| fann_train
| FANN_TRAIN_BATCH
| fann_train_enum
| fann_train_epoch
| FANN_TRAIN_INCREMENTAL
| FANN_TRAIN_NAMES
| fann_train_on_data
| fann_train_on_file
| FANN_TRAIN_QUICKPROP
| FANN_TRAIN_RPROP
| fann_type
| File Input and Output
| Functions neural_net training_data

> namespace FANN

The FANN namespace groups the C++ wrapper definitions
Cascade training differs from ordinary training in the sense that it starts with an empty neural network and then adds neurons one by one, while it trains the neural network.
The FANN library is designed to be very easy to use.
The two main datatypes used in the fann library is struct fann, which represents an artificial neural network, and struct fann_train_data, which represent training data.
Errors from the fann library are usually reported on stderr.
It is possible to save an entire ann to a file with fann_save for future loading with fann_create_from_file.
There are many different ways of training neural networks and the FANN library supports a number of different approaches.
The Fann Wrapper for C++ provides two classes: neural_net and training_data.
The activation functions used for the neurons during training.
Constant array consisting of the names for the activation function, so that the name of an activation function can be received by:
This callback function can be called during training when using fann_train_on_data, fann_train_on_file or fann_cascadetrain_on_data.

> FANN_EXTERNAL void FANN_API fann_cascadetrain_on_data(
> | struct | fann | * | ann,
> | struct | fann_train_data | * | data,
> | unsigned | int |  | max_neurons,
> | unsigned | int |  | neurons_between_reports,
> |  | float |  | desired_error
> )

Trains on an entire dataset, for a period of time using the Cascade2 training algorithm.

> FANN_EXTERNAL void FANN_API fann_cascadetrain_on_file(
> | struct | fann | * | ann,
> | const | char | * | filename,
> | unsigned | int |  | max_neurons,
> | unsigned | int |  | neurons_between_reports,
> |  | float |  | desired_error
> )

Does the same as fann_cascadetrain_on_data, but reads the training data directly from a file.

> FANN_EXTERNAL int FANN_API fann_clear_scaling_params( | struct | fann | * | ann | )

Clears scaling parameters.
Describes a connection between two neurons and its weight
Periodical cosinus activation function.
Periodical cosinus activation function.
Periodical cosinus activation function.

> FANN_EXTERNAL struct fann *FANN_API fann_create_from_file(
> | const | char | * | configuration_file
> )

Constructs a backpropagation neural network from a configuration file, which have been saved by fann_save.

> FANN_EXTERNAL struct fann *FANN_API fann_create_shortcut(
> | unsigned | int | num_layers,
> |  |  | ...
> )

Creates a standard backpropagation neural network, which is not fully connected and which also has shortcut connections.

> FANN_EXTERNAL struct fann *FANN_API fann_create_shortcut_array(
> | unsigned | int |  | num_layers,
> | const unsigned | int | * | layers
> )

Just like fann_create_shortcut, but with an array of layer sizes instead of individual parameters.

> FANN_EXTERNAL struct fann *FANN_API fann_create_sparse(
> |  | float | connection_rate,
> | unsigned | int | num_layers,
> |  |  | ...
> )

Creates a standard backpropagation neural network, which is not fully connected.

> FANN_EXTERNAL struct fann *FANN_API fann_create_sparse_array(
> |  | float |  | connection_rate,
> | unsigned | int |  | num_layers,
> | const unsigned | int | * | layers
> )

Just like fann_create_sparse, but with an array of layer sizes instead of individual parameters.

> FANN_EXTERNAL struct fann *FANN_API fann_create_standard(
> | unsigned | int | num_layers,
> |  |  | ...
> )

Creates a standard fully connected backpropagation neural network.

> FANN_EXTERNAL struct fann *FANN_API fann_create_standard_array(
> | unsigned | int |  | num_layers,
> | const unsigned | int | * | layers
> )

Just like fann_create_standard, but with an array of layer sizes instead of individual parameters.

> FANN_EXTERNAL struct fann_train_data * FANN_API fann_create_train_from_callback(
> | unsigned | int | num_data,
> | unsigned | int | num_input,
> | unsigned | int | num_output,
> |  | void | (FANN_API *user_function)( unsigned int, unsigned int, unsigned int, fann_type * , fann_type * )
> )

Creates the training data struct from a user supplied function.

> FANN_EXTERNAL void FANN_API fann_descale_input( | struct | fann | * | ann,
> |  | fann_type | * | input_vector | )

Scale data in input vector after get it from ann based on previously calculated parameters.

> FANN_EXTERNAL void FANN_API fann_descale_output( | struct | fann | * | ann,
> |  | fann_type | * | output_vector | )

Scale data in output vector after get it from ann based on previously calculated parameters.

> FANN_EXTERNAL void FANN_API fann_descale_train( | struct | fann | * | ann,
> | struct | fann_train_data | * | data | )

Descale input and output data based on previously calculated parameters.

> FANN_EXTERNAL void FANN_API fann_destroy( | struct | fann | * | ann | )

Destroys the entire network and properly freeing all the associated memmory.

> FANN_EXTERNAL void FANN_API fann_destroy_train(
> | struct | fann_train_data | * | train_data
> )

Destructs the training data and properly deallocates all of the associated data.

> FANN_EXTERNAL struct fann_train_data *FANN_API fann_duplicate_train_data(
> | struct | fann_train_data | * | data
> )

Returns an exact copy of a struct fann_train_data.
Unable to allocate memory
Unable to open configuration file for reading
Unable to open configuration file for writing
Unable to open train data file for reading
Unable to open train data file for writing
Error reading info from configuration file
Error reading connections from configuration file
Error reading neuron info from configuration file
Error reading training data from file
Unable to train with the selected activation function
Unable to use the selected activation function
Unable to use the selected training algorithm
Index is out of bound
No error
Scaling parameters not present
Irreconcilable differences between two struct fann_train_data structures
Trying to take subset which is not within the training set
Wrong version of configuration file
Number of connections not equal to the number expected
Fast (sigmoid like) activation function defined by David Elliott
Fast (sigmoid like) activation function defined by David Elliott
Fast (symmetric sigmoid like) activation function defined by David Elliott
Fast (symmetric sigmoid like) activation function defined by David Elliott
Used to define error events on struct fann and struct fann_train_data.
Error function used during training.
Standard linear error function.
Constant array consisting of the names for the training error functions, so that the name of an error function can be received by:
Tanh error function, usually better but can require a lower learning rate.
Gaussian activation function.
Gaussian activation function.
Symmetric gaussian activation function.
Symmetric gaussian activation function.

> FANN_EXTERNAL enum fann_activationfunc_enum FANN_API fann_get_activation_function(
> | struct | fann | * | ann,
> |  | int |  | layer,
> |  | int |  | neuron
> )

Get the activation function for neuron number neuron in layer number layer, counting the input layer as layer 0.

> FANN_EXTERNAL fann_type FANN_API fann_get_activation_steepness(
> | struct | fann | * | ann,
> |  | int |  | layer,
> |  | int |  | neuron
> )

Get the activation steepness for neuron number neuron in layer number layer, counting the input layer as layer 0.

> FANN_EXTERNAL void FANN_API fann_get_bias_array( | struct | fann | * | ann,
> | unsigned | int | * | bias | )

Get the number of bias in each layer in the network.

> FANN_EXTERNAL unsigned int FANN_API fann_get_bit_fail( | struct | fann | * | ann | )

The number of fail bits; means the number of output neurons which differ more than the bit fail limit (see fann_get_bit_fail_limit, fann_set_bit_fail_limit).

> FANN_EXTERNAL fann_type FANN_API fann_get_bit_fail_limit( | struct | fann | * | ann | )

Returns the bit fail limit used during training.

> FANN_EXTERNAL enum fann_activationfunc_enum * FANN_API fann_get_cascade_activation_functions(
> | struct | fann | * | ann
> )

The cascade activation functions array is an array of the different activation functions used by the candidates.

> FANN_EXTERNAL unsigned int FANN_API fann_get_cascade_activation_functions_count(
> | struct | fann | * | ann
> )

The number of activation functions in the fann_get_cascade_activation_functions array.

> FANN_EXTERNAL fann_type * FANN_API fann_get_cascade_activation_steepnesses(
> | struct | fann | * | ann
> )

The cascade activation steepnesses array is an array of the different activation functions used by the candidates.

> FANN_EXTERNAL unsigned int FANN_API fann_get_cascade_activation_steepnesses_count(
> | struct | fann | * | ann
> )

The number of activation steepnesses in the fann_get_cascade_activation_functions array.

> FANN_EXTERNAL float FANN_API fann_get_cascade_candidate_change_fraction(
> | struct | fann | * | ann
> )

The cascade candidate change fraction is a number between 0 and 1 determining how large a fraction the fann_get_MSE value should change within fann_get_cascade_candidate_stagnation_epochs during training of the candidate neurons, in order for the training not to stagnate.

> FANN_EXTERNAL fann_type FANN_API fann_get_cascade_candidate_limit(
> | struct | fann | * | ann
> )

The candidate limit is a limit for how much the candidate neuron may be trained.

> FANN_EXTERNAL unsigned int FANN_API fann_get_cascade_candidate_stagnation_epochs(
> | struct | fann | * | ann
> )

The number of cascade candidate stagnation epochs determines the number of epochs training is allowed to continue without changing the MSE by a fraction of fann_get_cascade_candidate_change_fraction.

> FANN_EXTERNAL unsigned int FANN_API fann_get_cascade_max_cand_epochs(
> | struct | fann | * | ann
> )

The maximum candidate epochs determines the maximum number of epochs the input connections to the candidates may be trained before adding a new candidate neuron.

> FANN_EXTERNAL unsigned int FANN_API fann_get_cascade_max_out_epochs(
> | struct | fann | * | ann
> )

The maximum out epochs determines the maximum number of epochs the output connections may be trained after adding a new candidate neuron.

> FANN_EXTERNAL unsigned int FANN_API fann_get_cascade_num_candidate_groups(
> | struct | fann | * | ann
> )

The number of candidate groups is the number of groups of identical candidates which will be used during training.

> FANN_EXTERNAL unsigned int FANN_API fann_get_cascade_num_candidates(
> | struct | fann | * | ann
> )

The number of candidates used during training (calculated by multiplying fann_get_cascade_activation_functions_count, fann_get_cascade_activation_steepnesses_count and fann_get_cascade_num_candidate_groups).

> FANN_EXTERNAL float FANN_API fann_get_cascade_output_change_fraction(
> | struct | fann | * | ann
> )

The cascade output change fraction is a number between 0 and 1 determining how large a fraction the fann_get_MSE value should change within fann_get_cascade_output_stagnation_epochs during training of the output connections, in order for the training not to stagnate.

> FANN_EXTERNAL unsigned int FANN_API fann_get_cascade_output_stagnation_epochs(
> | struct | fann | * | ann
> )

The number of cascade output stagnation epochs determines the number of epochs training is allowed to continue without changing the MSE by a fraction of fann_get_cascade_output_change_fraction.

> FANN_EXTERNAL fann_type FANN_API fann_get_cascade_weight_multiplier(
> | struct | fann | * | ann
> )

The weight multiplier is a parameter which is used to multiply the weights from the candidate neuron before adding the neuron to the neural network.

> FANN_EXTERNAL void FANN_API fann_get_connection_array(
> | struct | fann | * | ann,
> | struct | fann_connection | * | connections
> )

Get the connections in the network.

> FANN_EXTERNAL float FANN_API fann_get_connection_rate( | struct | fann | * | ann | )

Get the connection rate used when the network was created

> FANN_EXTERNAL unsigned int FANN_API fann_get_decimal_point( | struct | fann | * | ann | )

Returns the position of the decimal point in the ann.

> FANN_EXTERNAL enum fann_errno_enum FANN_API fann_get_errno(
> | struct | fann_error | * | errdat
> )

Returns the last error number.

> FANN_EXTERNAL char *FANN_API fann_get_errstr( | struct | fann_error | * | errdat | )

Returns the last errstr.

> FANN_EXTERNAL void FANN_API fann_get_layer_array( | struct | fann | * | ann,
> | unsigned | int | * | layers | )

Get the number of neurons in each layer in the network.

> FANN_EXTERNAL float FANN_API fann_get_learning_momentum( | struct | fann | * | ann | )

Get the learning momentum.

> FANN_EXTERNAL float FANN_API fann_get_learning_rate( | struct | fann | * | ann | )

Return the learning rate.

> FANN_EXTERNAL float FANN_API fann_get_MSE( | struct | fann | * | ann | )

Reads the mean square error from the network.

> FANN_EXTERNAL unsigned int FANN_API fann_get_multiplier( | struct | fann | * | ann | )

returns the multiplier that fix point data is multiplied with.

> FANN_EXTERNAL enum fann_nettype_enum FANN_API fann_get_network_type(
> | struct | fann | * | ann
> )

Get the type of neural network it was created as.

> FANN_EXTERNAL unsigned int FANN_API fann_get_num_input( | struct | fann | * | ann | )

Get the number of input neurons.

> FANN_EXTERNAL unsigned int FANN_API fann_get_num_layers( | struct | fann | * | ann | )

Get the number of layers in the network

> FANN_EXTERNAL unsigned int FANN_API fann_get_num_output( | struct | fann | * | ann | )

Get the number of output neurons.

> FANN_EXTERNAL float FANN_API fann_get_quickprop_decay( | struct | fann | * | ann | )

The decay is a small negative valued number which is the factor that the weights should become smaller in each iteration during quickprop training.

> FANN_EXTERNAL float FANN_API fann_get_quickprop_mu( | struct | fann | * | ann | )

The mu factor is used to increase and decrease the step-size during quickprop training.

> FANN_EXTERNAL float FANN_API fann_get_rprop_decrease_factor( | struct | fann | * | ann | )

The decrease factor is a value smaller than 1, which is used to decrease the step-size during RPROP training.

> FANN_EXTERNAL float FANN_API fann_get_rprop_delta_max( | struct | fann | * | ann | )

The maximum step-size is a positive number determining how large the maximum step-size may be.

> FANN_EXTERNAL float FANN_API fann_get_rprop_delta_min( | struct | fann | * | ann | )

The minimum step-size is a small positive number determining how small the minimum step-size may be.

> FANN_EXTERNAL float FANN_API fann_get_rprop_delta_zero( | struct | fann | * | ann | )

The initial step-size is a positive number determining the initial step size.

> FANN_EXTERNAL float FANN_API fann_get_rprop_increase_factor( | struct | fann | * | ann | )

The increase factor is a value larger than 1, which is used to increase the step-size during RPROP training.

> FANN_EXTERNAL unsigned int FANN_API fann_get_total_connections(
> | struct | fann | * | ann
> )

Get the total number of connections in the entire network.

> FANN_EXTERNAL unsigned int FANN_API fann_get_total_neurons( | struct | fann | * | ann | )

Get the total number of neurons in the entire network.

> FANN_EXTERNAL enum fann_errorfunc_enum FANN_API fann_get_train_error_function(
> | struct | fann | * | ann
> )

Returns the error function used during training.

> FANN_EXTERNAL enum fann_stopfunc_enum FANN_API fann_get_train_stop_function(
> | struct | fann | * | ann
> )

Returns the the stop function used during training.

> FANN_EXTERNAL enum fann_train_enum FANN_API fann_get_training_algorithm(
> | struct | fann | * | ann
> )

Return the training algorithm as described by fann_train_enum.

> FANN_EXTERNAL void * FANN_API fann_get_user_data( | struct | fann | * | ann | )

Get a pointer to user defined data that was previously set with fann_set_user_data.

> FANN_EXTERNAL void FANN_API fann_init_weights(
> | struct | fann | * | ann,
> | struct | fann_train_data | * | train_data
> )

Initialize the weights using Widrow + Nguyen’s algorithm.

> FANN_EXTERNAL unsigned int FANN_API fann_length_train_data(
> | struct | fann_train_data | * | data
> )

Returns the number of training patterns in the struct fann_train_data.
Linear activation function.
Linear activation function.
Bounded linear activation function.
Bounded linear activation function.
Bounded linear activation function.
Bounded Linear activation function.

> FANN_EXTERNAL struct fann_train_data *FANN_API fann_merge_train_data(
> | struct | fann_train_data | * | data1,
> | struct | fann_train_data | * | data2
> )

Merges the data from data1 and data2 into a new struct fann_train_data.
Each layer only has connections to the next layer
Each layer has connections to all following layers
Definition of network types used by fann_get_network_type
Constant array consisting of the names for the network types, so that the name of an network type can be received by:

> FANN_EXTERNAL unsigned int FANN_API fann_num_input_train_data(
> | struct | fann_train_data | * | data
> )

Returns the number of inputs in each of the training patterns in the struct fann_train_data.

> FANN_EXTERNAL unsigned int FANN_API fann_num_output_train_data(
> | struct | fann_train_data | * | data
> )

Returns the number of outputs in each of the training patterns in the struct fann_train_data.

> FANN_EXTERNAL void FANN_API fann_print_connections( | struct | fann | * | ann | )

Will print the connections of the ann in a compact matrix, for easy viewing of the internals of the ann.

> FANN_EXTERNAL void FANN_API fann_print_error( | struct | fann_error | * | errdat | )

Prints the last error to stderr.

> FANN_EXTERNAL void FANN_API fann_print_parameters( | struct | fann | * | ann | )

Prints all of the parameters and options of the ANN

> FANN_EXTERNAL void FANN_API fann_randomize_weights( | struct | fann | * | ann,
> |  | fann_type |  | min_weight,
> |  | fann_type |  | max_weight | )

Give each connection a random weight between min_weight and max_weight

> FANN_EXTERNAL struct fann_train_data *FANN_API fann_read_train_from_file(
> | const | char | * | filename
> )

Reads a file that stores training data.

> FANN_EXTERNAL void FANN_API fann_reset_errno( | struct | fann_error | * | errdat | )

Resets the last error number.

> FANN_EXTERNAL void FANN_API fann_reset_errstr( | struct | fann_error | * | errdat | )

Resets the last error string.

> FANN_EXTERNAL void FANN_API fann_reset_MSE( | struct | fann | * | ann | )

Resets the mean square error from the network.

> FANN_EXTERNAL fann_type * FANN_API fann_run( | struct | fann | * | ann,
> |  | fann_type | * | input | )

Will run input through the neural network, returning an array of outputs, the number of which being equal to the number of neurons in the output layer.

> FANN_EXTERNAL int FANN_API fann_save( | struct | fann | * | ann,
> | const | char | * | configuration_file | )

Save the entire network to a configuration file.

> FANN_EXTERNAL int FANN_API fann_save_to_fixed( | struct | fann | * | ann,
> | const | char | * | configuration_file | )

Saves the entire network to a configuration file.

> FANN_EXTERNAL int FANN_API fann_save_train( | struct | fann_train_data | * | data,
> | const | char | * | filename | )

Save the training structure to a file, with the format as specified in fann_read_train_from_file

> FANN_EXTERNAL int FANN_API fann_save_train_to_fixed(
> | struct | fann_train_data | * | data,
> | const | char | * | filename,
> | unsigned | int |  | decimal_point
> )

Saves the training structure to a fixed point data file.

> FANN_EXTERNAL void FANN_API fann_scale_input( | struct | fann | * | ann,
> |  | fann_type | * | input_vector | )

Scale data in input vector before feed it to ann based on previously calculated parameters.

> FANN_EXTERNAL void FANN_API fann_scale_input_train_data(
> | struct | fann_train_data | * | train_data,
> |  | fann_type |  | new_min,
> |  | fann_type |  | new_max
> )

Scales the inputs in the training data to the specified range.

> FANN_EXTERNAL void FANN_API fann_scale_output( | struct | fann | * | ann,
> |  | fann_type | * | output_vector | )

Scale data in output vector before feed it to ann based on previously calculated parameters.

> FANN_EXTERNAL void FANN_API fann_scale_output_train_data(
> | struct | fann_train_data | * | train_data,
> |  | fann_type |  | new_min,
> |  | fann_type |  | new_max
> )

Scales the outputs in the training data to the specified range.

> FANN_EXTERNAL void FANN_API fann_scale_train( | struct | fann | * | ann,
> | struct | fann_train_data | * | data | )

Scale input and output data based on previously calculated parameters.

> FANN_EXTERNAL void FANN_API fann_scale_train_data(
> | struct | fann_train_data | * | train_data,
> |  | fann_type |  | new_min,
> |  | fann_type |  | new_max
> )

Scales the inputs and outputs in the training data to the specified range.

> FANN_EXTERNAL void FANN_API fann_set_activation_function(
> | struct | fann | * | ann,
> | enum | fann_activationfunc_enum |  | activation_function,
> |  | int |  | layer,
> |  | int |  | neuron
> )

Set the activation function for neuron number neuron in layer number layer, counting the input layer as layer 0.

> FANN_EXTERNAL void FANN_API fann_set_activation_function_hidden(
> | struct | fann | * | ann,
> | enum | fann_activationfunc_enum |  | activation_function
> )

Set the activation function for all of the hidden layers.

> FANN_EXTERNAL void FANN_API fann_set_activation_function_layer(
> | struct | fann | * | ann,
> | enum | fann_activationfunc_enum |  | activation_function,
> |  | int |  | layer
> )

Set the activation function for all the neurons in the layer number layer, counting the input layer as layer 0.

> FANN_EXTERNAL void FANN_API fann_set_activation_function_output(
> | struct | fann | * | ann,
> | enum | fann_activationfunc_enum |  | activation_function
> )

Set the activation function for the output layer.

> FANN_EXTERNAL void FANN_API fann_set_activation_steepness( | struct | fann | * | ann,
> |  | fann_type |  | steepness,
> |  | int |  | layer,
> |  | int |  | neuron | )

Set the activation steepness for neuron number neuron in layer number layer, counting the input layer as layer 0.

> FANN_EXTERNAL void FANN_API fann_set_activation_steepness_hidden(
> | struct | fann | * | ann,
> |  | fann_type |  | steepness
> )

Set the steepness of the activation steepness in all of the hidden layers.

> FANN_EXTERNAL void FANN_API fann_set_activation_steepness_layer(
> | struct | fann | * | ann,
> |  | fann_type |  | steepness,
> |  | int |  | layer
> )

Set the activation steepness all of the neurons in layer number layer, counting the input layer as layer 0.

> FANN_EXTERNAL void FANN_API fann_set_activation_steepness_output(
> | struct | fann | * | ann,
> |  | fann_type |  | steepness
> )

Set the steepness of the activation steepness in the output layer.

> FANN_EXTERNAL void FANN_API fann_set_bit_fail_limit( | struct | fann | * | ann,
> |  | fann_type |  | bit_fail_limit | )

Set the bit fail limit used during training.

> FANN_EXTERNAL void FANN_API fann_set_callback( | struct | fann | * | ann,
> |  | fann_callback_type |  | callback | )

Sets the callback function for use during training.

> FANN_EXTERNAL void FANN_API fann_set_cascade_activation_functions(
> | struct | fann | * | ann,
> | enum | fann_activationfunc_enum | * | cascade_activation_functions,
> | unsigned | int |  | cascade_activation_functions_count
> )

Sets the array of cascade candidate activation functions.

> FANN_EXTERNAL void FANN_API fann_set_cascade_activation_steepnesses(
> | struct | fann | * | ann,
> |  | fann_type | * | cascade_activation_steepnesses,
> | unsigned | int |  | cascade_activation_steepnesses_count
> )

Sets the array of cascade candidate activation steepnesses.

> FANN_EXTERNAL void FANN_API fann_set_cascade_candidate_change_fraction(
> | struct | fann | * | ann,
> |  | float |  | cascade_candidate_change_fraction
> )

Sets the cascade candidate change fraction.

> FANN_EXTERNAL void FANN_API fann_set_cascade_candidate_limit(
> | struct | fann | * | ann,
> |  | fann_type |  | cascade_candidate_limit
> )

Sets the candidate limit.

> FANN_EXTERNAL void FANN_API fann_set_cascade_candidate_stagnation_epochs(
> | struct | fann | * | ann,
> | unsigned | int |  | cascade_candidate_stagnation_epochs
> )

Sets the number of cascade candidate stagnation epochs.

> FANN_EXTERNAL void FANN_API fann_set_cascade_max_cand_epochs(
> | struct | fann | * | ann,
> | unsigned | int |  | cascade_max_cand_epochs
> )

Sets the max candidate epochs.

> FANN_EXTERNAL void FANN_API fann_set_cascade_max_out_epochs(
> | struct | fann | * | ann,
> | unsigned | int |  | cascade_max_out_epochs
> )

Sets the maximum out epochs.

> FANN_EXTERNAL void FANN_API fann_set_cascade_num_candidate_groups(
> | struct | fann | * | ann,
> | unsigned | int |  | cascade_num_candidate_groups
> )

Sets the number of candidate groups.

> FANN_EXTERNAL void FANN_API fann_set_cascade_output_change_fraction(
> | struct | fann | * | ann,
> |  | float |  | cascade_output_change_fraction
> )

Sets the cascade output change fraction.

> FANN_EXTERNAL void FANN_API fann_set_cascade_output_stagnation_epochs(
> | struct | fann | * | ann,
> | unsigned | int |  | cascade_output_stagnation_epochs
> )

Sets the number of cascade output stagnation epochs.

> FANN_EXTERNAL void FANN_API fann_set_cascade_weight_multiplier(
> | struct | fann | * | ann,
> |  | fann_type |  | cascade_weight_multiplier
> )

Sets the weight multiplier.

> FANN_EXTERNAL void FANN_API fann_set_error_log( | struct | fann_error | * | errdat,
> |  | FILE | * | log_file | )

Change where errors are logged to.

> FANN_EXTERNAL int FANN_API fann_set_input_scaling_params(
> | struct | fann | * | ann,
> | const struct | fann_train_data | * | data,
> |  | float |  | new_input_min,
> |  | float |  | new_input_max
> )

Calculate input scaling parameters for future use based on training data.

> FANN_EXTERNAL void FANN_API fann_set_learning_momentum( | struct | fann | * | ann,
> |  | float |  | learning_momentum | )

Set the learning momentum.

> FANN_EXTERNAL void FANN_API fann_set_learning_rate( | struct | fann | * | ann,
> |  | float |  | learning_rate | )

Set the learning rate.

> FANN_EXTERNAL int FANN_API fann_set_output_scaling_params(
> | struct | fann | * | ann,
> | const struct | fann_train_data | * | data,
> |  | float |  | new_output_min,
> |  | float |  | new_output_max
> )

Calculate output scaling parameters for future use based on training data.

> FANN_EXTERNAL void FANN_API fann_set_quickprop_decay( | struct | fann | * | ann,
> |  | float |  | quickprop_decay | )

Sets the quickprop decay factor.

> FANN_EXTERNAL void FANN_API fann_set_quickprop_mu( | struct | fann | * | ann,
> |  | float |  | quickprop_mu | )

Sets the quickprop mu factor.

> FANN_EXTERNAL void FANN_API fann_set_rprop_decrease_factor(
> | struct | fann | * | ann,
> |  | float |  | rprop_decrease_factor
> )

The decrease factor is a value smaller than 1, which is used to decrease the step-size during RPROP training.

> FANN_EXTERNAL void FANN_API fann_set_rprop_delta_max( | struct | fann | * | ann,
> |  | float |  | rprop_delta_max | )

The maximum step-size is a positive number determining how large the maximum step-size may be.

> FANN_EXTERNAL void FANN_API fann_set_rprop_delta_min( | struct | fann | * | ann,
> |  | float |  | rprop_delta_min | )

The minimum step-size is a small positive number determining how small the minimum step-size may be.

> FANN_EXTERNAL void FANN_API fann_set_rprop_delta_zero( | struct | fann | * | ann,
> |  | float |  | rprop_delta_max | )

The initial step-size is a positive number determining the initial step size.

> FANN_EXTERNAL void FANN_API fann_set_rprop_increase_factor(
> | struct | fann | * | ann,
> |  | float |  | rprop_increase_factor
> )

The increase factor used during RPROP training.

> FANN_EXTERNAL int FANN_API fann_set_scaling_params(
> | struct | fann | * | ann,
> | const struct | fann_train_data | * | data,
> |  | float |  | new_input_min,
> |  | float |  | new_input_max,
> |  | float |  | new_output_min,
> |  | float |  | new_output_max
> )

Calculate input and output scaling parameters for future use based on training data.

> FANN_EXTERNAL void FANN_API fann_set_train_error_function(
> | struct | fann | * | ann,
> | enum | fann_errorfunc_enum |  | train_error_function
> )

Set the error function used during training.

> FANN_EXTERNAL void FANN_API fann_set_train_stop_function(
> | struct | fann | * | ann,
> | enum | fann_stopfunc_enum |  | train_stop_function
> )

Set the stop function used during training.

> FANN_EXTERNAL void FANN_API fann_set_training_algorithm(
> | struct | fann | * | ann,
> | enum | fann_train_enum |  | training_algorithm
> )

Set the training algorithm.

> FANN_EXTERNAL void FANN_API fann_set_user_data( | struct | fann | * | ann,
> |  | void | * | user_data | )

Store a pointer to user defined data.

> FANN_EXTERNAL void FANN_API fann_set_weight( | struct | fann | * | ann,
> | unsigned | int |  | from_neuron,
> | unsigned | int |  | to_neuron,
> |  | fann_type |  | weight | )

Set a connection in the network.

> FANN_EXTERNAL void FANN_API fann_set_weight_array(
> | struct | fann | * | ann,
> | struct | fann_connection | * | connections,
> | unsigned | int |  | num_connections
> )

Set connections in the network.

> FANN_EXTERNAL void FANN_API fann_shuffle_train_data(
> | struct | fann_train_data | * | train_data
> )

Shuffles training data, randomizing the order.
Sigmoid activation function.
Sigmoid activation function.
Stepwise linear approximation to sigmoid.
Stepwise linear approximation to sigmoid.
Symmetric sigmoid activation function, aka.
Symmetric sigmoid activation function, aka.
Periodical sinus activation function.
Periodical sinus activation function.
Periodical sinus activation function.
Stop criteria is number of bits that fail.
Stop criteria used during training.
Stop criteria is Mean Square Error (MSE) value.
Constant array consisting of the names for the training stop functions, so that the name of a stop function can be received by:

> FANN_EXTERNAL struct fann_train_data *FANN_API fann_subset_train_data(
> | struct | fann_train_data | * | data,
> | unsigned | int |  | pos,
> | unsigned | int |  | length
> )

Returns an copy of a subset of the struct fann_train_data, starting at position pos and length elements forward.

> FANN_EXTERNAL fann_type * FANN_API fann_test( | struct | fann | * | ann,
> |  | fann_type | * | input,
> |  | fann_type | * | desired_output | )

Test with a set of inputs, and a set of desired outputs.

> FANN_EXTERNAL float FANN_API fann_test_data( | struct | fann | * | ann,
> | struct | fann_train_data | * | data | )

Test a set of training data and calculates the MSE for the training data.
Threshold activation function.
Threshold activation function.
Threshold activation function.
Threshold activation function.

> FANN_EXTERNAL void FANN_API fann_train( | struct | fann | * | ann,
> |  | fann_type | * | input,
> |  | fann_type | * | desired_output | )

Train one iteration with a set of inputs, and a set of desired outputs.
Standard backpropagation algorithm, where the weights are updated after calculating the mean square error for the whole training set.
The Training algorithms used when training on struct fann_train_data with functions like fann_train_on_data or fann_train_on_file.

> FANN_EXTERNAL float FANN_API fann_train_epoch( | struct | fann | * | ann,
> | struct | fann_train_data | * | data | )

Train one epoch with a set of training data.
Standard backpropagation algorithm, where the weights are updated after each training pattern.
Constant array consisting of the names for the training algorithms, so that the name of an training function can be received by:

> FANN_EXTERNAL void FANN_API fann_train_on_data(
> | struct | fann | * | ann,
> | struct | fann_train_data | * | data,
> | unsigned | int |  | max_epochs,
> | unsigned | int |  | epochs_between_reports,
> |  | float |  | desired_error
> )

Trains on an entire dataset, for a period of time.

> FANN_EXTERNAL void FANN_API fann_train_on_file(
> | struct | fann | * | ann,
> | const | char | * | filename,
> | unsigned | int |  | max_epochs,
> | unsigned | int |  | epochs_between_reports,
> |  | float |  | desired_error
> )

Does the same as fann_train_on_data, but reads the training data directly from a file.
A more advanced batch training algorithm which achieves good results for many problems.
A more advanced batch training algorithm which achieves good results for many problems.
fann_type is the type used for the weights, inputs and outputs of the neural network.
Close